From 87b4a35ac7c4178bedf6f27ba35a0f2e5ec83bf3 Mon Sep 17 00:00:00 2001
From: 5g0Wp7Zy <yrk@yrkdeMacBook-Pro.local>
Date: Fri, 5 Dec 2025 16:57:20 +0800
Subject: [PATCH] =?UTF-8?q?feat:=E6=96=B0=E5=A2=9E=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/api/operator.ts                           |  16 +-
 src/api/types/operator.ts                     |   9 +
 .../instructTools/instructTools.vue           |   1 +
 .../faultReporting/faultReporting.vue         |   4 +-
 src/pages-sub/warehouse/polling/polling.vue   | 484 ++++++++++++++++++
 src/pages/home/home.vue                       | 137 +++--
 src/pages/me/me.vue                           |   6 +-
 src/store/app.ts                              |   4 +-
 src/style/iconfont.css                        |   6 +-
 src/style/index.scss                          |  61 +++
 src/utils/map.ts                              |   1 +
 ....timestamp-1764924993165-1a68b7648e66d.mjs | 381 ++++++++++++++
 12 files changed, 1061 insertions(+), 49 deletions(-)
 create mode 100644 src/pages-sub/warehouse/polling/polling.vue
 create mode 100644 vite.config.ts.timestamp-1764924993165-1a68b7648e66d.mjs

diff --git a/src/api/operator.ts b/src/api/operator.ts
index de96e3d..a6f7ff4 100644
--- a/src/api/operator.ts
+++ b/src/api/operator.ts
@@ -1,4 +1,4 @@
-import type { AddInventoryRecordParams, BatchAddInventoryParams, BindEbikeParams } from './types/operator'
+import type { AddInventoryRecordParams, BatchAddInventoryParams, BindEbikeParams, CompleteInspectionWorkParams } from './types/operator'
 import { http } from '@/http/http'
 
 /**
@@ -75,3 +75,17 @@ export function getEbikeDetailForWorkAPI(bikeCode: string) {
 export function getAllOperatorRegionAPI() {
   return http.get<any>(`/operations/ebikeRegion/list`)
 }
+
+/**
+ *车辆列表（工单用）
+ */
+export function getEbikeListForWorkAPI(regionId: string) {
+  return http.get<any>(`/operations/ebikeBikeOrder/bikeList`, { regionId })
+}
+
+/**
+ *完成巡检工单
+ */
+export function completeInspectionWorkAPI(params: CompleteInspectionWorkParams) {
+  return http.post<any>(`/operations/ebikeBikeOrder/doInspection`, params)
+}
diff --git a/src/api/types/operator.ts b/src/api/types/operator.ts
index 667e96c..49905c4 100644
--- a/src/api/types/operator.ts
+++ b/src/api/types/operator.ts
@@ -33,3 +33,12 @@ export interface BindEbikeParams {
   hasHelme: boolean // 是否有头盔
   remarks?: string // 备注
 }
+
+// 完成巡检工单
+export interface CompleteInspectionWorkParams {
+  bikeCode: string // 车辆编号
+  beforeInspectionFileUrls: string[] // 巡检前图片
+  afterInspectionFileUrls: string[] // 巡检后图片
+  isFault: boolean
+  remarks: string
+}
diff --git a/src/components/instructTools/instructTools.vue b/src/components/instructTools/instructTools.vue
index 0c9ca41..25300ed 100644
--- a/src/components/instructTools/instructTools.vue
+++ b/src/components/instructTools/instructTools.vue
@@ -99,6 +99,7 @@ async function handleBtnClick(value: any, key: string, index: number) {
 }
 
 watch(() => props.bikeCode, (val) => {
+  console.log(val, '2222')
   bikecode.value = val
 })
 </script>
diff --git a/src/pages-sub/warehouse/faultReporting/faultReporting.vue b/src/pages-sub/warehouse/faultReporting/faultReporting.vue
index edddf2e..6841bb4 100644
--- a/src/pages-sub/warehouse/faultReporting/faultReporting.vue
+++ b/src/pages-sub/warehouse/faultReporting/faultReporting.vue
@@ -86,10 +86,12 @@ async function afterRead(event: any) {
         },
       })
       formData.value.fileUrls.push(result[0])
+      console.log(result)
+
       fileList.value.splice(fileListLen, 1, Object.assign(item, {
         status: 'success',
         message: '',
-        url: result[0].fileUrl,
+        url: result[0],
       }))
       fileListLen++
     }
diff --git a/src/pages-sub/warehouse/polling/polling.vue b/src/pages-sub/warehouse/polling/polling.vue
new file mode 100644
index 0000000..7867551
--- /dev/null
+++ b/src/pages-sub/warehouse/polling/polling.vue
@@ -0,0 +1,484 @@
+<script lang="ts" setup>
+import { completeInspectionWorkAPI, getEbikeDetailForWorkAPI } from '@/api/operator'
+import { faultUrl, uploadImagesStrict } from '@/api/upload'
+import instructTools from '@/components/instructTools/instructTools.vue'
+import { useAppStore } from '@/store'
+import CacheManager from '@/utils/CacheManager'
+import { scanCode } from '@/utils/tools'
+
+definePage({
+  style: {
+    navigationBarTitleText: '车辆巡检',
+    navigationBarBackgroundColor: '#1488f5',
+    navigationBarTextStyle: 'white',
+  },
+})
+
+const appStore = useAppStore()
+const paging = ref<any>(null)
+const carIds = ref<any>('')
+const formRef = ref<any>(null)
+const carDetails = ref<any>({
+  bikeCode: '',
+})
+const customStyle = computed(() => {
+  return {
+    height: '60rpx',
+    fontSize: '26rpx',
+    padding: '20rpx 15rpx',
+  }
+})
+const radiolist = ref([
+  {
+    name: '苹果',
+  },
+  {
+    name: '香蕉',
+  },
+])
+
+/**
+ * 表单数据
+ */
+const isSubmit = ref(false)
+const limit = ref(4)
+const fileList_before = ref([])
+const fileList_after = ref([])
+const formData = ref({
+  bikeCode: '',
+  beforeInspectionFileUrls: [],
+  afterInspectionFileUrls: [],
+  isFault: false,
+  remarks: '',
+})
+const rules = {
+  isFault: {
+    type: 'boolean',
+    required: true,
+    message: '请选择',
+    trigger: 'change',
+  },
+}
+
+// 扫码
+function handleScan() {
+  scanCode({
+    success: (res: any) => {
+      carIds.value = res.code
+      getEbikeDetail()
+    },
+    fail: () => {
+      uni.showToast({
+        title: '扫码失败',
+        icon: 'none',
+      })
+    },
+  })
+}
+
+// 获取车辆详情
+async function getEbikeDetail() {
+  uni.showLoading({
+    title: '查询中...',
+  })
+  try {
+    const res = await getEbikeDetailForWorkAPI(carIds.value)
+    if (res) {
+      carDetails.value = res
+    }
+  }
+  catch (e) {
+    console.error('查询车辆详情失败')
+  }
+  finally {
+    uni.hideLoading()
+  }
+}
+
+// 地图找车
+function handleMapClick() {
+  const { latitude, longitude } = carDetails.value.location
+  const params = {
+    elng: longitude,
+    elat: latitude,
+  }
+  uni.navigateTo({
+    url: `/pages-sub/map/findCar/findCar?params=${encodeURIComponent(JSON.stringify(params))}`,
+  })
+}
+
+// 上传图片
+async function afterRead(event: any, type: string) {
+  const lists = [].concat(event.file)
+  let fileListLen = type === 'before' ? fileList_before.value.length : fileList_after.value.length
+  const token = CacheManager.get('token')
+
+  lists.forEach((item) => {
+    if (type === 'before') {
+      fileList_before.value.push({
+        ...item,
+        status: 'uploading',
+        message: '上传中',
+      })
+    }
+    else {
+      fileList_after.value.push({
+        ...item,
+        status: 'uploading',
+        message: '上传中',
+      })
+    }
+  })
+
+  for (let i = 0; i < lists.length; i++) {
+    const item = type === 'before' ? fileList_before.value[fileListLen] : fileList_after.value[fileListLen]
+    try {
+      const result: any = await uploadImagesStrict([lists[i].url], faultUrl, {
+        name: 'file',
+        header: {
+          'Authorization': token,
+          'Content-Type': 'multipart/form-data',
+        },
+      })
+      console.log(result)
+
+      // 列表参数添加
+      if (type === 'before') {
+        formData.value.beforeInspectionFileUrls.push(result[0])
+      }
+      else {
+        formData.value.afterInspectionFileUrls.push(result[0])
+      }
+
+      if (type === 'before') {
+        fileList_before.value.splice(fileListLen, 1, Object.assign(item, {
+          status: 'success',
+          message: '',
+          url: result[0],
+        }))
+      }
+      else {
+        fileList_after.value.splice(fileListLen, 1, Object.assign(item, {
+          status: 'success',
+          message: '',
+          url: result[0],
+        }))
+      }
+      fileListLen++
+    }
+    catch (err) {
+      console.log('错误')
+
+      if (type === 'before') {
+        fileList_before.value.splice(fileListLen, 1, Object.assign(item, {
+          status: 'failed',
+          message: '',
+          url: '',
+        }))
+      }
+      else {
+        fileList_after.value.splice(fileListLen, 1, Object.assign(item, {
+          status: 'failed',
+          message: '',
+          url: '',
+        }))
+      }
+    }
+  }
+}
+
+// 删除图片
+function deletePic(e: any, type: string) {
+  if (type === 'before') {
+    fileList_before.value.splice(e.index, 1)
+    formData.value.beforeInspectionFileUrls.splice(e.index, 1)
+  }
+  else {
+    fileList_after.value.splice(e.index, 1)
+    formData.value.afterInspectionFileUrls.splice(e.index, 1)
+  }
+}
+
+// 表单重置
+function resetForm() {
+  formData.value = {
+    bikeCode: '',
+    beforeInspectionFileUrls: [],
+    afterInspectionFileUrls: [],
+    isFault: false,
+    remarks: '',
+  }
+  fileList_before.value = []
+  fileList_after.value = []
+  if (formRef.value) {
+    formRef.value.resetFields()
+  }
+}
+
+// 提交表单
+async function handleComplete() {
+  if (!carIds.value) {
+    return uni.showToast({
+      title: '请输入车牌号',
+      icon: 'none',
+    })
+  }
+
+  isSubmit.value = true
+  try {
+    const status = await formRef.value.validate()
+    if (status) {
+      const res: any = await completeInspectionWorkAPI({
+        ...formData.value,
+        bikeCode: carIds.value,
+      })
+      uni.showToast({
+        title: '提交成功',
+        icon: 'none',
+      })
+      resetForm()
+    }
+  }
+  catch (e: any) {
+    console.error('提交失败')
+  }
+  finally {
+    isSubmit.value = false
+  }
+}
+
+onLoad((query) => {
+  const { bikeCode } = query
+  if (bikeCode) {
+    carIds.value = bikeCode
+    getEbikeDetail()
+  }
+})
+</script>
+
+<template>
+  <z-paging
+    ref="paging"
+    bg-color="#f3f3f3"
+  >
+    <view class="y_card2_wrapper">
+      <!-- 详情 -->
+      <view class="card_box">
+        <!-- 车辆编号 -->
+        <view class="card_row_long_3">
+          <view class="key">
+            车辆编号
+          </view>
+          <view class="value">
+            <uv-input v-model="carIds" placeholder="请输入或扫码" border="none" />
+          </view>
+          <view class="icon">
+            <uv-icon name="scan" color="#1488f5" size="24" @click="handleScan" />
+          </view>
+        </view>
+        <!-- 第1行 -->
+        <view class="card_row">
+          <view class="row_item">
+            <text class="label">在线状态</text>
+            <text
+              class="value"
+              :style="{
+                color: carDetails.online ? '#85c262' : carIds ? 'red' : '',
+              }"
+            >
+              {{ carDetails.online ? '在线' : carIds ? '离线' : '--' }}
+            </text>
+          </view>
+          <view class="row_item">
+            <text class="label">实时电量</text>
+            <text class="value">{{ carDetails.soc || '--' }}%</text>
+          </view>
+        </view>
+        <!-- 第2行 -->
+        <view class="card_row">
+          <view class="row_item">
+            <text class="label">车辆状态</text>
+            <text class="value">{{ appStore.translateDictValue(carDetails.usageStatus, 'BikeUsageStatus') || '--' }}</text>
+          </view>
+          <view class="row_item">
+            <text class="label">实时电压</text>
+            <text class="value">{{ carDetails.voltage || '--' }}V</text>
+          </view>
+        </view>
+        <!-- 第3行 -->
+        <view class="card_row">
+          <view class="row_item">
+            <text class="label">电门状态</text>
+            <text class="value">{{ carDetails.accOn || '--' }}</text>
+          </view>
+          <view class="row_item">
+            <text class="label">轮锁状态</text>
+            <text class="value">{{ carDetails.wheelLocked || '--' }}</text>
+          </view>
+        </view>
+        <!-- 第4行 -->
+        <view class="card_row">
+          <view class="row_item">
+            <text class="label">电池仓状态</text>
+            <text class="value">{{ carDetails.seatLocked || '--' }}</text>
+          </view>
+          <view class="row_item">
+            <text class="label">网络信号</text>
+            <text class="value">{{ carDetails.gsm || '--' }}</text>
+          </view>
+        </view>
+        <!-- 第5行 -->
+        <view class="card_row">
+          <view class="row_item">
+            <text class="label">运动状态</text>
+            <text class="value">{{ carDetails.isMoving || '--' }}</text>
+          </view>
+          <view class="row_item">
+            <text class="label">车辆速度</text>
+            <text class="value">{{ carDetails.speed || '--' }}</text>
+          </view>
+        </view>
+        <!-- 第6行 -->
+        <view class="card_row">
+          <view class="row_item">
+            <text class="label">头盔锁状态</text>
+            <text class="value">{{ carDetails.isHelmetLocked || '--' }}</text>
+          </view>
+          <view class="row_item">
+            <text class="label">头盔是否在位</text>
+            <text class="value">{{ carDetails.helmetExit || '--' }}</text>
+          </view>
+        </view>
+        <!-- 车辆编号 -->
+        <view class="card_row_long_3">
+          <view class="key">
+            最新定位
+          </view>
+          <view class="value">
+            {{ carDetails.chineseLocation || '--' }}
+          </view>
+          <view class="icon">
+            <uv-button
+              type="primary"
+              :plain="true"
+              text="地图找车"
+              icon-color="#1488f5"
+              icon="map"
+              shape="circle"
+              :custom-style="customStyle"
+              @click="handleMapClick"
+            />
+          </view>
+        </view>
+      </view>
+      <!-- 操作 -->
+      <view class="card_box">
+        <instructTools :bike-code="carIds" />
+      </view>
+
+      <!-- 表单填写 -->
+      <view class="card_box">
+        <uv-form
+          ref="formRef"
+          label-position="top"
+          :model="formData"
+          :rules="rules"
+          :label-width="300"
+          :label-style="{
+            fontSize: '28rpx',
+            color: '#969696',
+          }"
+        >
+          <!-- TUDU:没有确定 -->
+          <!-- <uv-form-item label="巡检类型" prop="">
+            <uv-radio-group v-model="formData.radiovalue">
+              <uv-radio
+                v-for="(item, index) in radiolist"
+                :key="index"
+                :custom-style="{ margin: '8px' }"
+                :label="item.name"
+                :name="item.name"
+              />
+            </uv-radio-group>
+          </uv-form-item> -->
+          <uv-form-item label="是否直接上报故障" prop="isFault" required>
+            <uv-radio-group v-model="formData.isFault">
+              <uv-radio
+                :custom-style="{ margin: '8px' }"
+                label="否"
+                :name="false"
+              />
+              <uv-radio
+                :custom-style="{ margin: '8px' }"
+                label="是"
+                :name="true"
+              />
+            </uv-radio-group>
+          </uv-form-item>
+          <uv-form-item label="巡检前照片(最多4张)" prop="beforeInspectionFileUrls">
+            <uv-upload
+              :file-list="fileList_before"
+              name="before"
+              multiple
+              :max-count="limit"
+              :preview-full-image="true"
+              @after-read="(e:any) => afterRead(e, 'before')"
+              @delete="(e:any) => deletePic(e, 'before')"
+            />
+          </uv-form-item>
+          <uv-form-item label="巡检后照片(最多4张)" prop="afterInspectionFileUrls">
+            <uv-upload
+              :file-list="fileList_after"
+              name="after"
+              multiple
+              :max-count="limit"
+              :preview-full-image="true"
+              @after-read="(e:any) => afterRead(e, 'after')"
+              @delete="(e:any) => deletePic(e, 'after')"
+            />
+          </uv-form-item>
+          <uv-form-item label="巡检备注" prop="remarks">
+            <uv-textarea v-model="formData.remarks" placeholder="请输入备注内容" />
+          </uv-form-item>
+        </uv-form>
+        <!-- 提示 -->
+        <view class="tips_bar">
+          <view class="title">
+            温馨提示
+          </view>
+          <view class="text">
+            1、请根据要求提交照片，将以此作为审核参考凭证。
+          </view>
+        </view>
+      </view>
+    </view>
+
+    <template #bottom>
+      <view class="bottom-button-zaping">
+        <uv-button
+          type="primary"
+          :loading="isSubmit"
+          text="确认提交"
+          loading-text="提交中..."
+          @click="handleComplete"
+        />
+      </view>
+    </template>
+  </z-paging>
+</template>
+
+<style lang="scss" scoped>
+.tips_bar {
+  color: #b3b3b3;
+
+  .title {
+    font-size: 32rpx;
+    margin: 15rpx 0;
+  }
+
+  .text {
+    font-size: 28rpx;
+    margin: 10rpx 0;
+  }
+}
+</style>
diff --git a/src/pages/home/home.vue b/src/pages/home/home.vue
index 2f1b911..df4eabe 100644
--- a/src/pages/home/home.vue
+++ b/src/pages/home/home.vue
@@ -1,5 +1,5 @@
 <script lang="ts" setup>
-import { getAllOperatorRegionAPI, getEbikeDetailAPI } from '@/api/operator'
+import { getAllOperatorRegionAPI, getEbikeDetailForWorkAPI, getEbikeListForWorkAPI } from '@/api/operator'
 import AMapWX from '@/plugIns/amap-wx.130.js'
 import { addLine, drawPoint, drawRegion, getLoalcation, getMapContext, getRoutePlan } from '@/utils/map'
 import { systemInfo } from '@/utils/systemInfo'
@@ -14,7 +14,7 @@ const amapsdk = new AMapWX({
 const navBarHeight = systemInfo.statusBarHeight * 2 + 80 || 200// 导航栏高度
 const height = (systemInfo.screenHeight - navBarHeight)
 
-type ToolsType = 'dispatch' | 'charge' | 'none'
+type ToolsType = 'dispatch' | 'charge' | 'none' | 'polling' | 'maintain'
 
 definePage({
   style: {
@@ -22,12 +22,7 @@ definePage({
   },
 })
 
-// 车辆详情卡片配置
-const carDetailsShow = reactive<any>({
-  show: false,
-  key: 'charge', // 记录工具类型
-})
-const list = ref([
+const tablist = ref<any>([
   {
     name: '换电',
     key: 'charge',
@@ -36,14 +31,28 @@ const list = ref([
     name: '调度',
     key: 'dispatch',
   },
+  {
+    name: '巡检',
+    key: 'polling',
+  },
+  {
+    name: '维修',
+    key: 'maintain',
+  },
 ])
-// 工具类型
-const toolsType = ref<ToolsType>('charge')
-// 获取车辆详情
-const carDetaile = ref<any>({
+const bikeList = ref<any>([]) // 车辆列表
+const toolsType = ref<ToolsType>(tablist.value[0].key)// 工具类型
+const carDetaile = ref<any>({ // 获取车辆详情
   distance: '',
 })
+const carDetailsShow = reactive<any>({ // 车辆详情卡片配置
+  show: false,
+  key: tablist.value[0].key, // 记录工具类型
+})
 
+/**
+ * 弹窗配置
+ */
 const popupRef = ref<any>(null) // 弹窗
 const regionList = ref<any>([]) // 区域列表
 const selectRegion = ref<any>({}) // 选中的区域
@@ -72,6 +81,7 @@ function tabClick(item: any) {
   toolsType.value = item.key
   carDetailsShow.show = false
   mapPolylines.value = []
+  drawMapPoint(toolsType.value)
 }
 // 定位
 function orientation() {
@@ -108,10 +118,74 @@ function regionchange(e: any) {
 //   visionCenter.longitude = centerLocation.longitude
 }
 
+// 获取车辆列表
+async function getEbikeList(regionId: string) {
+  try {
+    const res: any = await getEbikeListForWorkAPI(regionId)
+    if (Array.isArray(res) && res.length > 0) {
+      bikeList.value = res
+    }
+    return Promise.resolve(res)
+  }
+  catch (e) {
+    uni.showToast({
+      title: '获取车辆列表失败',
+      icon: 'none',
+    })
+    console.error('获取车辆列表失败')
+  }
+}
+
+// 绘制点位信息
+function drawMapPoint(orderType: string) {
+  if (!bikeList.value || bikeList.value.length === 0) {
+    return
+  }
+  mapMarkers.value = []
+  let list = []
+
+  // 换电
+  if (orderType === tablist.value[0].key) {
+    list = bikeList.value.filter((item: any) => item.hasChangeBatteryOrder)
+  }
+  // 调度
+  if (orderType === tablist.value[1].key) {
+    list = bikeList.value.filter((item: any) => item.hasDispatchOrder)
+  }
+  // 巡检
+  if (orderType === tablist.value[2].key) {
+    list = bikeList.value.filter((item: any) => item.hasInspectionOrder)
+  }
+  // 维修
+  if (orderType === tablist.value[3].key) {
+    list = bikeList.value.filter((item: any) => item.hasRepairOrder)
+  }
+
+  // 绘制点位
+  if (list.length > 0) {
+    list.forEach((bike: any) => {
+      drawPoint({
+        point: {
+          bikeCode: bike.bikeCode,
+          longitude: bike.location.longitude,
+          latitude: bike.location.latitude,
+        },
+        success(res) {
+          mapMarkers.value.push(res)
+        },
+        fail(res) {
+          console.error(res)
+        },
+      })
+    })
+  }
+}
+
 // 地图初始化
 async function initMap() {
-  console.log(getCurrentInstance())
-  mapContext.value = getMapContext('mapRef', getCurrentInstance())
+  if (!mapContext.value) {
+    mapContext.value = getMapContext('mapRef', getCurrentInstance())
+  }
   orientation()
 
   // 获取运营区域
@@ -119,22 +193,9 @@ async function initMap() {
   // 设置运营区域
   drawMapPolygons(regionList.value[0].regionId)
   setSelectedRegion(regionList.value[0].regionId)
-  drawPoint({
-    point: {
-      bikeCode: '43497692725',
-      longitude: 104.07,
-      latitude: 30.61,
-    },
-    success(res) {
-      console.log(res)
-      mapMarkers.value = [res]
-      console.log(mapMarkers.value)
-    },
-    fail(res) {
-      console.log(res)
-    },
-
-  })
+  // 根据运营区域获取车辆列表
+  await getEbikeList(regionList.value[0].regionId)
+  drawMapPoint(toolsType.value)
 }
 
 // 监听点击marker事件
@@ -144,9 +205,7 @@ async function handleMarkertap(e: any) {
   // 从列表中查找对应车辆信息
   const item = mapMarkers.value.find(item => item.id === id)
   try {
-    const res: any = await getEbikeDetailAPI(item.id.toString())
-    console.log(res)
-
+    const res: any = await getEbikeDetailForWorkAPI(item.id.toString())
     if (res) {
       carDetaile.value = res
     }
@@ -245,18 +304,14 @@ function drawMapPolygons(regionId: string) {
   if (!regionId) {
     return
   }
-  const region = regionList.value.find(item => item.regionId === regionId)
-  console.log(region)
+  const region = regionList.value.find((item: any) => item.regionId === regionId)
   if (region) {
     const { coordinates } = region.regionPolygon
     drawRegion({
       point: coordinates,
       isFormat: true,
       success(res) {
-        console.log(res, '地图绘制成功')
-
         mapPolygons.value = [res]
-        console.log(mapPolygons.value, '地图绘制相关方法')
       },
       fail(err) {
         console.error(err)
@@ -290,9 +345,11 @@ function backRegion() {
 }
 
 // 确定
-function handleRegion() {
+async function handleRegion() {
+  await getEbikeList(selectRegionMiddle.value.regionId)
   setSelectedRegion(selectRegionMiddle.value.regionId)
   drawMapPolygons(selectRegionMiddle.value.regionId)
+  drawMapPoint(toolsType.value)
   backRegion()
 }
 function handleRegionClick(item: any) {
@@ -311,7 +368,7 @@ onMounted(() => {
       <view class="tabs">
         <uv-tabs
           line-color="#ffffff"
-          :list="list" :active-style="{
+          :list="tablist" :active-style="{
             color: '#ffffff',
             fontWeight: 'bold',
             transform: 'scale(1.05)',
diff --git a/src/pages/me/me.vue b/src/pages/me/me.vue
index 57f2b76..4cde036 100644
--- a/src/pages/me/me.vue
+++ b/src/pages/me/me.vue
@@ -43,9 +43,9 @@ const btnList = ref([
       },
       {
         key: 'checkdevice',
-        name: '设备检查',
-        path: '/pages/devops/checkDevice/checkDevice',
-        customsrc: 'btn_tongyong_shebeijiancha',
+        name: '巡检',
+        path: '/pages-sub/warehouse/polling/polling',
+        customsrc: 'xunjianrenwu',
       },
       {
         key: 'faultreport',
diff --git a/src/store/app.ts b/src/store/app.ts
index 5bca687..05eae3e 100644
--- a/src/store/app.ts
+++ b/src/store/app.ts
@@ -117,9 +117,7 @@ export const useAppStore = defineStore(
       if (list.length > 0) {
         const values = list[0].values
         if (values && values.length > 0) {
-          console.log(values)
-          console.log(value)
-          return values.find((item: any) => item.dicValue === value.toString())?.dicValueName || value
+          return values.find((item: any) => item.dicValue === value?.toString())?.dicValueName || value
         }
       }
       return value
diff --git a/src/style/iconfont.css b/src/style/iconfont.css
index 0785032..48d9279 100644
--- a/src/style/iconfont.css
+++ b/src/style/iconfont.css
@@ -1,6 +1,6 @@
 @font-face {
   font-family: 'custom-icon'; /* Project id 5039526 */
-  src: url('data:application/x-font-woff2;charset=utf-8;base64,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')
+  src: url('data:application/x-font-woff2;charset=utf-8;base64,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')
     format('woff2');
 }
 
@@ -12,6 +12,10 @@
   -moz-osx-font-smoothing: grayscale;
 }
 
+.custom-icon-xunjianrenwu:before {
+  content: '\e68b';
+}
+
 .custom-icon-dakaitoukuisuo:before {
   content: '\e636';
 }
diff --git a/src/style/index.scss b/src/style/index.scss
index ceec552..62bdd2d 100644
--- a/src/style/index.scss
+++ b/src/style/index.scss
@@ -132,3 +132,64 @@ border-t-1
     }
   }
 }
+
+/* 卡片样式2-一行2列的形式 */
+.y_card2_wrapper {
+  padding: 20rpx 0;
+  width: 100%;
+
+  .card_box {
+    padding: 30rpx;
+    width: calc(100% - 60rpx);
+    background-color: white;
+    box-shadow: 0 0 6rpx rgba(0, 0, 0, 0.1);
+    margin-bottom: 30rpx;
+
+    .card_row {
+      display: flex;
+      justify-content: space-between;
+      margin: 25rpx 0;
+
+      .row_item {
+        flex: 1;
+        display: flex;
+
+        .label {
+          font-size: 28rpx;
+          color: #989898;
+          width: 150rpx;
+        }
+
+        .value {
+          font-size: 28rpx;
+          color: #141414;
+        }
+      }
+    }
+
+    .card_row_long_3 {
+      width: 100%;
+      display: flex;
+      justify-content: space-between;
+      margin: 10rpx 0;
+
+      .key {
+        font-size: 28rpx;
+        color: #989898;
+        width: 150rpx;
+      }
+
+      .value {
+        font-size: 28rpx;
+        color: #141414;
+        width: calc(100% - 255rpx);
+      }
+
+      .icon {
+        width: 120rpx;
+        display: flex;
+        justify-content: flex-end;
+      }
+    }
+  }
+}
diff --git a/src/utils/map.ts b/src/utils/map.ts
index bfc3449..c4d0181 100644
--- a/src/utils/map.ts
+++ b/src/utils/map.ts
@@ -296,6 +296,7 @@ export function drawPoint({
   success: (res: any) => void
   fail: (res: any) => void
 }) {
+  // console.log(point, '------------>point')
   let obj = {}
 
   if (!point) {
diff --git a/vite.config.ts.timestamp-1764924993165-1a68b7648e66d.mjs b/vite.config.ts.timestamp-1764924993165-1a68b7648e66d.mjs
new file mode 100644
index 0000000..d4199d1
--- /dev/null
+++ b/vite.config.ts.timestamp-1764924993165-1a68b7648e66d.mjs
@@ -0,0 +1,381 @@
+// vite.config.ts
+import path4 from "node:path";
+import process4 from "node:process";
+import Uni from "file:///Users/yrk/Desktop/ebike-ui%EF%BC%88new%EF%BC%89/ebike-plus-wx-maintenance/node_modules/.pnpm/@uni-helper+plugin-uni@0.1.0_@dcloudio+vite-plugin-uni@3.0.0-4070620250821001_postcss@8_0531a23cbdff7442fc614704e222f868/node_modules/@uni-helper/plugin-uni/src/index.js";
+import Components from "file:///Users/yrk/Desktop/ebike-ui%EF%BC%88new%EF%BC%89/ebike-plus-wx-maintenance/node_modules/.pnpm/@uni-helper+vite-plugin-uni-components@0.2.3_rollup@4.52.4/node_modules/@uni-helper/vite-plugin-uni-components/dist/index.mjs";
+import UniLayouts from "file:///Users/yrk/Desktop/ebike-ui%EF%BC%88new%EF%BC%89/ebike-plus-wx-maintenance/node_modules/.pnpm/@uni-helper+vite-plugin-uni-layouts@0.1.11_rollup@4.52.4/node_modules/@uni-helper/vite-plugin-uni-layouts/dist/index.mjs";
+import UniManifest from "file:///Users/yrk/Desktop/ebike-ui%EF%BC%88new%EF%BC%89/ebike-plus-wx-maintenance/node_modules/.pnpm/@uni-helper+vite-plugin-uni-manifest@0.2.8_vite@5.2.8_@types+node@20.19.20_sass@1.77.8_terser@5.44.0_/node_modules/@uni-helper/vite-plugin-uni-manifest/dist/index.mjs";
+import UniPages from "file:///Users/yrk/Desktop/ebike-ui%EF%BC%88new%EF%BC%89/ebike-plus-wx-maintenance/node_modules/.pnpm/@uni-helper+vite-plugin-uni-pages@0.3.13_vite@5.2.8_@types+node@20.19.20_sass@1.77.8_terser@5.44.0_/node_modules/@uni-helper/vite-plugin-uni-pages/dist/index.mjs";
+import UniPlatform from "file:///Users/yrk/Desktop/ebike-ui%EF%BC%88new%EF%BC%89/ebike-plus-wx-maintenance/node_modules/.pnpm/@uni-helper+vite-plugin-uni-platform@0.0.5/node_modules/@uni-helper/vite-plugin-uni-platform/dist/index.mjs";
+import Optimization from "file:///Users/yrk/Desktop/ebike-ui%EF%BC%88new%EF%BC%89/ebike-plus-wx-maintenance/node_modules/.pnpm/@uni-ku+bundle-optimizer@1.3.15-beta.2_postcss@8.5.6_rollup@4.52.4_vite@5.2.8_@types+no_98b8d82f5a06a130481e14836684597c/node_modules/@uni-ku/bundle-optimizer/dist/index.mjs";
+import UniKuRoot from "file:///Users/yrk/Desktop/ebike-ui%EF%BC%88new%EF%BC%89/ebike-plus-wx-maintenance/node_modules/.pnpm/@uni-ku+root@1.4.1_vite@5.2.8_@types+node@20.19.20_sass@1.77.8_terser@5.44.0_/node_modules/@uni-ku/root/dist/index.mjs";
+import dayjs from "file:///Users/yrk/Desktop/ebike-ui%EF%BC%88new%EF%BC%89/ebike-plus-wx-maintenance/node_modules/.pnpm/dayjs@1.11.10/node_modules/dayjs/dayjs.min.js";
+import { visualizer } from "file:///Users/yrk/Desktop/ebike-ui%EF%BC%88new%EF%BC%89/ebike-plus-wx-maintenance/node_modules/.pnpm/rollup-plugin-visualizer@6.0.4_rollup@4.52.4/node_modules/rollup-plugin-visualizer/dist/plugin/index.js";
+import UnoCSS from "file:///Users/yrk/Desktop/ebike-ui%EF%BC%88new%EF%BC%89/ebike-plus-wx-maintenance/node_modules/.pnpm/unocss@66.0.0_postcss@8.5.6_vite@5.2.8_@types+node@20.19.20_sass@1.77.8_terser@5.44.0__vue@3.5.22_typescript@5.8.3_/node_modules/unocss/dist/vite.mjs";
+import AutoImport from "file:///Users/yrk/Desktop/ebike-ui%EF%BC%88new%EF%BC%89/ebike-plus-wx-maintenance/node_modules/.pnpm/unplugin-auto-import@20.2.0/node_modules/unplugin-auto-import/dist/vite.js";
+import { defineConfig, loadEnv } from "file:///Users/yrk/Desktop/ebike-ui%EF%BC%88new%EF%BC%89/ebike-plus-wx-maintenance/node_modules/.pnpm/vite@5.2.8_@types+node@20.19.20_sass@1.77.8_terser@5.44.0/node_modules/vite/dist/node/index.js";
+import ViteRestart from "file:///Users/yrk/Desktop/ebike-ui%EF%BC%88new%EF%BC%89/ebike-plus-wx-maintenance/node_modules/.pnpm/vite-plugin-restart@1.0.0_vite@5.2.8_@types+node@20.19.20_sass@1.77.8_terser@5.44.0_/node_modules/vite-plugin-restart/dist/index.js";
+
+// scripts/open-dev-tools.js
+import { exec } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+function _openDevTools() {
+  const platform = process.platform;
+  const { UNI_PLATFORM } = process.env;
+  const uniPlatformText = UNI_PLATFORM === "mp-weixin" ? "\u5FAE\u4FE1\u5C0F\u7A0B\u5E8F" : UNI_PLATFORM === "mp-alipay" ? "\u652F\u4ED8\u5B9D\u5C0F\u7A0B\u5E8F" : "\u5C0F\u7A0B\u5E8F";
+  const projectPath = path.resolve(process.cwd(), `dist/dev/${UNI_PLATFORM}`);
+  if (!fs.existsSync(projectPath)) {
+    console.log(`\u274C ${uniPlatformText}\u6784\u5EFA\u76EE\u5F55\u4E0D\u5B58\u5728:`, projectPath);
+    return;
+  }
+  console.log(`\u{1F680} \u6B63\u5728\u6253\u5F00${uniPlatformText}\u5F00\u53D1\u8005\u5DE5\u5177...`);
+  let command = "";
+  if (platform === "darwin") {
+    if (UNI_PLATFORM === "mp-weixin") {
+      command = `/Applications/wechatwebdevtools.app/Contents/MacOS/cli -o "${projectPath}"`;
+    } else if (UNI_PLATFORM === "mp-alipay") {
+      command = `/Applications/\u5C0F\u7A0B\u5E8F\u5F00\u53D1\u8005\u5DE5\u5177.app/Contents/MacOS/\u5C0F\u7A0B\u5E8F\u5F00\u53D1\u8005\u5DE5\u5177 --p "${projectPath}"`;
+    }
+  } else if (platform === "win32" || platform === "win64") {
+    if (UNI_PLATFORM === "mp-weixin") {
+      command = `"C:\\Program Files (x86)\\Tencent\\\u5FAE\u4FE1web\u5F00\u53D1\u8005\u5DE5\u5177\\cli.bat" -o "${projectPath}"`;
+    }
+  } else {
+    console.log("\u274C \u5F53\u524D\u7CFB\u7EDF\u4E0D\u652F\u6301\u81EA\u52A8\u6253\u5F00\u5FAE\u4FE1\u5F00\u53D1\u8005\u5DE5\u5177");
+    return;
+  }
+  exec(command, (error, stdout, stderr) => {
+    if (error) {
+      console.log(`\u274C \u6253\u5F00${uniPlatformText}\u5F00\u53D1\u8005\u5DE5\u5177\u5931\u8D25:`, error.message);
+      console.log(`\u{1F4A1} \u8BF7\u786E\u4FDD${uniPlatformText}\u5F00\u53D1\u8005\u5DE5\u5177\u670D\u52A1\u7AEF\u53E3\u5DF2\u542F\u7528`);
+      console.log(`\u{1F4A1} \u53EF\u4EE5\u624B\u52A8\u6253\u5F00${uniPlatformText}\u5F00\u53D1\u8005\u5DE5\u5177\u5E76\u5BFC\u5165\u9879\u76EE:`, projectPath);
+      return;
+    }
+    if (stderr) {
+      console.log("\u26A0\uFE0F \u8B66\u544A:", stderr);
+    }
+    console.log(`\u2705 ${uniPlatformText}\u5F00\u53D1\u8005\u5DE5\u5177\u5DF2\u6253\u5F00`);
+    if (stdout) {
+      console.log(stdout);
+    }
+  });
+}
+function openDevTools() {
+  let isFirstBuild = true;
+  return {
+    name: "uni-devtools",
+    writeBundle() {
+      if (isFirstBuild && process.env.UNI_PLATFORM?.includes("mp")) {
+        isFirstBuild = false;
+        _openDevTools();
+      }
+    }
+  };
+}
+
+// vite-plugins/copy-native-resources.ts
+import path2 from "node:path";
+import process2 from "node:process";
+import fs2 from "file:///Users/yrk/Desktop/ebike-ui%EF%BC%88new%EF%BC%89/ebike-plus-wx-maintenance/node_modules/.pnpm/fs-extra@10.1.0/node_modules/fs-extra/lib/index.js";
+var DEFAULT_OPTIONS = {
+  enable: true,
+  sourceDir: "nativeplugins",
+  targetDirName: "nativeplugins",
+  verbose: true,
+  logPrefix: "[copy-native-resources]"
+};
+function copyNativeResources(options = {}) {
+  const config = { ...DEFAULT_OPTIONS, ...options };
+  if (!config.enable) {
+    return {
+      name: "copy-native-resources-disabled",
+      apply: "build",
+      writeBundle() {
+      }
+    };
+  }
+  return {
+    name: "copy-native-resources",
+    apply: "build",
+    // 只在构建时应用
+    enforce: "post",
+    // 在其他插件执行完毕后执行
+    async writeBundle() {
+      const { sourceDir, targetDirName, verbose, logPrefix } = config;
+      try {
+        const projectRoot = process2.cwd();
+        const sourcePath = path2.resolve(projectRoot, sourceDir);
+        const buildMode = process2.env.NODE_ENV === "production" ? "build" : "dev";
+        const platform = process2.env.UNI_PLATFORM || "app";
+        const targetPath = path2.resolve(
+          projectRoot,
+          "dist",
+          buildMode,
+          platform,
+          targetDirName
+        );
+        const sourceExists = await fs2.pathExists(sourcePath);
+        if (!sourceExists) {
+          if (verbose) {
+            console.warn(`${logPrefix} \u6E90\u76EE\u5F55\u4E0D\u5B58\u5728\uFF0C\u8DF3\u8FC7\u590D\u5236\u64CD\u4F5C`);
+            console.warn(`${logPrefix} \u6E90\u76EE\u5F55\u8DEF\u5F84: ${sourcePath}`);
+            console.warn(`${logPrefix} \u5982\u9700\u4F7F\u7528\u672C\u5730\u539F\u751F\u63D2\u4EF6\uFF0C\u8BF7\u5728\u9879\u76EE\u6839\u76EE\u5F55\u521B\u5EFA nativeplugins \u76EE\u5F55`);
+            console.warn(`${logPrefix} \u5E76\u6309\u7167\u5B98\u65B9\u6587\u6863\u653E\u5165\u539F\u751F\u63D2\u4EF6\u6587\u4EF6`);
+            console.warn(`${logPrefix} \u53C2\u8003: https://uniapp.dcloud.net.cn/plugin/native-plugin.html`);
+          }
+          return;
+        }
+        const sourceFiles = await fs2.readdir(sourcePath);
+        if (sourceFiles.length === 0) {
+          if (verbose) {
+            console.warn(`${logPrefix} \u6E90\u76EE\u5F55\u4E3A\u7A7A\uFF0C\u8DF3\u8FC7\u590D\u5236\u64CD\u4F5C`);
+            console.warn(`${logPrefix} \u6E90\u76EE\u5F55\u8DEF\u5F84: ${sourcePath}`);
+            console.warn(`${logPrefix} \u8BF7\u5728 nativeplugins \u76EE\u5F55\u4E2D\u653E\u5165\u539F\u751F\u63D2\u4EF6\u6587\u4EF6`);
+          }
+          return;
+        }
+        await fs2.ensureDir(targetPath);
+        if (verbose) {
+          console.log(`${logPrefix} \u5F00\u59CB\u590D\u5236 UniApp \u672C\u5730\u539F\u751F\u63D2\u4EF6...`);
+          console.log(`${logPrefix} \u6E90\u76EE\u5F55: ${sourcePath}`);
+          console.log(`${logPrefix} \u76EE\u6807\u76EE\u5F55: ${targetPath}`);
+          console.log(`${logPrefix} \u6784\u5EFA\u6A21\u5F0F: ${buildMode}`);
+          console.log(`${logPrefix} \u76EE\u6807\u5E73\u53F0: ${platform}`);
+          console.log(`${logPrefix} \u53D1\u73B0 ${sourceFiles.length} \u4E2A\u539F\u751F\u63D2\u4EF6\u6587\u4EF6/\u76EE\u5F55`);
+        }
+        await fs2.copy(sourcePath, targetPath, {
+          overwrite: true,
+          // 覆盖已存在的文件，确保使用最新版本
+          errorOnExist: false,
+          // 如果目标文件存在不报错
+          preserveTimestamps: true
+          // 保持文件的时间戳
+        });
+        if (verbose) {
+          console.log(`${logPrefix} \u2705 UniApp \u672C\u5730\u539F\u751F\u63D2\u4EF6\u590D\u5236\u5B8C\u6210`);
+          console.log(`${logPrefix} \u5DF2\u6210\u529F\u590D\u5236 ${sourceFiles.length} \u4E2A\u6587\u4EF6/\u76EE\u5F55\u5230\u6784\u5EFA\u76EE\u5F55`);
+          console.log(`${logPrefix} \u539F\u751F\u63D2\u4EF6\u73B0\u5728\u53EF\u4EE5\u5728 App \u4E2D\u6B63\u5E38\u4F7F\u7528`);
+        }
+      } catch (error) {
+        console.error(`${config.logPrefix} \u274C \u590D\u5236 UniApp \u672C\u5730\u539F\u751F\u63D2\u4EF6\u5931\u8D25:`, error);
+        console.error(`${config.logPrefix} \u9519\u8BEF\u8BE6\u60C5:`, error instanceof Error ? error.message : String(error));
+        console.error(`${config.logPrefix} \u8BF7\u68C0\u67E5\u6E90\u76EE\u5F55\u6743\u9650\u548C\u78C1\u76D8\u7A7A\u95F4`);
+      }
+    }
+  };
+}
+function createCopyNativeResourcesPlugin(enable = true, options = {}) {
+  return copyNativeResources({ enable, ...options });
+}
+
+// vite-plugins/sync-manifest-plugins.ts
+import fs3 from "node:fs";
+import path3 from "node:path";
+import process3 from "node:process";
+function syncManifestPlugin() {
+  return {
+    name: "sync-manifest",
+    apply: "build",
+    enforce: "post",
+    writeBundle: {
+      order: "post",
+      handler() {
+        const srcManifestPath = path3.resolve(process3.cwd(), "./src/manifest.json");
+        const distAppPath = path3.resolve(process3.cwd(), "./dist/dev/app/manifest.json");
+        try {
+          const srcManifest = JSON.parse(fs3.readFileSync(srcManifestPath, "utf8"));
+          const distAppDir = path3.dirname(distAppPath);
+          if (!fs3.existsSync(distAppDir)) {
+            fs3.mkdirSync(distAppDir, { recursive: true });
+          }
+          let distManifest = {};
+          if (fs3.existsSync(distAppPath)) {
+            distManifest = JSON.parse(fs3.readFileSync(distAppPath, "utf8"));
+          }
+          if (srcManifest["app-plus"]?.distribute?.plugins) {
+            if (!distManifest.plus)
+              distManifest.plus = {};
+            if (!distManifest.plus.distribute)
+              distManifest.plus.distribute = {};
+            distManifest.plus.distribute.plugins = srcManifest["app-plus"].distribute.plugins;
+            fs3.writeFileSync(distAppPath, JSON.stringify(distManifest, null, 2));
+            console.log("\u2705 Manifest plugins \u540C\u6B65\u6210\u529F");
+          }
+        } catch (error) {
+          console.error("\u274C \u540C\u6B65 manifest plugins \u5931\u8D25:", error);
+        }
+      }
+    }
+  };
+}
+
+// vite.config.ts
+var vite_config_default = defineConfig(({ command, mode }) => {
+  console.log("command, mode -> ", command, mode);
+  const { UNI_PLATFORM } = process4.env;
+  console.log("UNI_PLATFORM -> ", UNI_PLATFORM);
+  const env = loadEnv(mode, path4.resolve(process4.cwd(), "env"));
+  const {
+    VITE_APP_PORT,
+    VITE_SERVER_BASEURL,
+    VITE_APP_TITLE,
+    VITE_DELETE_CONSOLE,
+    VITE_APP_PUBLIC_BASE,
+    VITE_APP_PROXY_ENABLE,
+    VITE_APP_PROXY_PREFIX,
+    VITE_COPY_NATIVE_RES_ENABLE
+  } = env;
+  console.log("\u73AF\u5883\u53D8\u91CF env -> ", env);
+  return defineConfig({
+    envDir: "./env",
+    // 自定义env目录
+    base: VITE_APP_PUBLIC_BASE,
+    plugins: [
+      UniPages({
+        exclude: ["**/components/**/**.*"],
+        // pages 目录为 src/pages，分包目录不能配置在pages目录下！！
+        // 是个数组，可以配置多个，但是不能为pages里面的目录！！
+        subPackages: [
+          "src/pages-fg",
+          // 这个是相对必要的路由，尽量留着（登录页、注册页、404页等）
+          "src/pages-sub"
+          // 这个多为示例代码，参考用的，开发完后注释掉即可（或者直接删除）
+        ],
+        dts: "src/types/uni-pages.d.ts"
+      }),
+      UniLayouts(),
+      UniPlatform(),
+      UniManifest(),
+      // Optimization 插件需要 page.json 文件，故应在 UniPages 插件之后执行
+      Optimization({
+        enable: {
+          "optimization": true,
+          "async-import": true,
+          "async-component": true
+        },
+        dts: {
+          base: "src/types"
+        },
+        logger: false
+      }),
+      // UniXXX 需要在 Uni 之前引入
+      {
+        // 临时解决 dcloudio 官方的 @dcloudio/uni-mp-compiler 出现的编译 BUG
+        // 参考 github issue: https://github.com/dcloudio/uni-app/issues/4952
+        // 自定义插件禁用 vite:vue 插件的 devToolsEnabled，强制编译 vue 模板时 inline 为 true
+        name: "fix-vite-plugin-vue",
+        configResolved(config) {
+          const plugin = config.plugins.find((p) => p.name === "vite:vue");
+          if (plugin && plugin.api && plugin.api.options) {
+            plugin.api.options.devToolsEnabled = false;
+          }
+        }
+      },
+      UnoCSS(),
+      AutoImport({
+        imports: ["vue", "uni-app"],
+        dts: "src/types/auto-import.d.ts",
+        dirs: ["src/hooks"],
+        // 自动导入 hooks
+        vueTemplate: true
+        // default false
+      }),
+      ViteRestart({
+        // 通过这个插件，在修改vite.config.js文件则不需要重新运行也生效配置
+        restart: ["vite.config.js"]
+      }),
+      // h5环境增加 BUILD_TIME 和 BUILD_BRANCH
+      UNI_PLATFORM === "h5" && {
+        name: "html-transform",
+        transformIndexHtml(html) {
+          return html.replace("%BUILD_TIME%", dayjs().format("YYYY-MM-DD HH:mm:ss")).replace("%VITE_APP_TITLE%", VITE_APP_TITLE);
+        }
+      },
+      // 打包分析插件，h5 + 生产环境才弹出
+      UNI_PLATFORM === "h5" && mode === "production" && visualizer({
+        filename: "./node_modules/.cache/visualizer/stats.html",
+        open: true,
+        gzipSize: true,
+        brotliSize: true
+      }),
+      // 原生插件资源复制插件 - 仅在 app 平台且启用时生效
+      createCopyNativeResourcesPlugin(
+        UNI_PLATFORM === "app" && VITE_COPY_NATIVE_RES_ENABLE === "true",
+        {
+          verbose: mode === "development"
+          // 开发模式显示详细日志
+        }
+      ),
+      syncManifestPlugin(),
+      Components({
+        extensions: ["vue"],
+        deep: true,
+        // 是否递归扫描子目录，
+        directoryAsNamespace: false,
+        // 是否把目录名作为命名空间前缀，true 时组件名为 目录名+组件名，
+        dts: "src/types/components.d.ts"
+        // 自动生成的组件类型声明文件路径（用于 TypeScript 支持）
+      }),
+      // 若存在改变 pages.json 的插件，请将 UniKuRoot 放置其后
+      UniKuRoot(),
+      Uni(),
+      // 自动打开开发者工具插件 (必须修改 .env 文件中的 VITE_WX_APPID)
+      openDevTools()
+    ],
+    define: {
+      __VITE_APP_PROXY__: JSON.stringify(VITE_APP_PROXY_ENABLE)
+    },
+    css: {
+      preprocessorOptions: {
+        scss: {
+          additionalData: `@import "@/style/color.scss";`
+        }
+      },
+      postcss: {
+        plugins: [
+          // autoprefixer({
+          //   // 指定目标浏览器
+          //   overrideBrowserslist: ['> 1%', 'last 2 versions'],
+          // }),
+        ]
+      }
+    },
+    resolve: {
+      alias: {
+        "@": path4.join(process4.cwd(), "./src"),
+        "@img": path4.join(process4.cwd(), "./src/static/images")
+      }
+    },
+    server: {
+      host: "0.0.0.0",
+      hmr: true,
+      port: Number.parseInt(VITE_APP_PORT, 10),
+      // 仅 H5 端生效，其他端不生效（其他端走build，不走devServer)
+      proxy: JSON.parse(VITE_APP_PROXY_ENABLE) ? {
+        [VITE_APP_PROXY_PREFIX]: {
+          target: VITE_SERVER_BASEURL,
+          changeOrigin: true,
+          // 后端有/api前缀则不做处理，没有则需要去掉
+          rewrite: (path5) => path5.replace(new RegExp(`^${VITE_APP_PROXY_PREFIX}`), "")
+        }
+      } : void 0
+    },
+    esbuild: {
+      drop: VITE_DELETE_CONSOLE === "true" ? ["console"] : []
+    },
+    build: {
+      sourcemap: false,
+      // 方便非h5端调试
+      // sourcemap: VITE_SHOW_SOURCEMAP === 'true', // 默认是false
+      target: "es6",
+      // 开发环境不用压缩
+      minify: mode === "development" ? false : "esbuild"
+    }
+  });
+});
+export {
+  vite_config_default as default
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["vite.config.ts", "scripts/open-dev-tools.js", "vite-plugins/copy-native-resources.ts", "vite-plugins/sync-manifest-plugins.ts"],
  "sourcesContent": ["const __vite_injected_original_dirname = \"/Users/yrk/Desktop/ebike-ui\uFF08new\uFF09/ebike-plus-wx-maintenance\";const __vite_injected_original_filename = \"/Users/yrk/Desktop/ebike-ui\uFF08new\uFF09/ebike-plus-wx-maintenance/vite.config.ts\";const __vite_injected_original_import_meta_url = \"file:///Users/yrk/Desktop/ebike-ui%EF%BC%88new%EF%BC%89/ebike-plus-wx-maintenance/vite.config.ts\";import path from 'node:path'\nimport process from 'node:process'\nimport Uni from '@uni-helper/plugin-uni'\nimport Components from '@uni-helper/vite-plugin-uni-components'\n// @see https://uni-helper.js.org/vite-plugin-uni-layouts\nimport UniLayouts from '@uni-helper/vite-plugin-uni-layouts'\n// @see https://github.com/uni-helper/vite-plugin-uni-manifest\nimport UniManifest from '@uni-helper/vite-plugin-uni-manifest'\n// @see https://uni-helper.js.org/vite-plugin-uni-pages\nimport UniPages from '@uni-helper/vite-plugin-uni-pages'\n// @see https://github.com/uni-helper/vite-plugin-uni-platform\n// \u9700\u8981\u4E0E @uni-helper/vite-plugin-uni-pages \u63D2\u4EF6\u4E00\u8D77\u4F7F\u7528\nimport UniPlatform from '@uni-helper/vite-plugin-uni-platform'\n/**\n * \u5206\u5305\u4F18\u5316\u3001\u6A21\u5757\u5F02\u6B65\u8DE8\u5305\u8C03\u7528\u3001\u7EC4\u4EF6\u5F02\u6B65\u8DE8\u5305\u5F15\u7528\n * @see https://github.com/uni-ku/bundle-optimizer\n */\nimport Optimization from '@uni-ku/bundle-optimizer'\n// https://github.com/uni-ku/root\nimport UniKuRoot from '@uni-ku/root'\nimport dayjs from 'dayjs'\nimport { visualizer } from 'rollup-plugin-visualizer'\nimport UnoCSS from 'unocss/vite'\nimport AutoImport from 'unplugin-auto-import/vite'\nimport { defineConfig, loadEnv } from 'vite'\nimport ViteRestart from 'vite-plugin-restart'\nimport openDevTools from './scripts/open-dev-tools'\nimport { createCopyNativeResourcesPlugin } from './vite-plugins/copy-native-resources'\nimport syncManifestPlugin from './vite-plugins/sync-manifest-plugins'\n\n// https://vitejs.dev/config/\nexport default defineConfig(({ command, mode }) => {\n  // @see https://unocss.dev/\n  // const UnoCSS = (await import('unocss/vite')).default\n  // console.log(mode === process.env.NODE_ENV) // true\n\n  // mode: \u533A\u5206\u751F\u4EA7\u73AF\u5883\u8FD8\u662F\u5F00\u53D1\u73AF\u5883\n  console.log('command, mode -> ', command, mode)\n  // pnpm dev:h5 \u65F6\u5F97\u5230 => serve development\n  // pnpm build:h5 \u65F6\u5F97\u5230 => build production\n  // pnpm dev:mp-weixin \u65F6\u5F97\u5230 => build development (\u6CE8\u610F\u533A\u522B\uFF0Ccommand\u4E3Abuild)\n  // pnpm build:mp-weixin \u65F6\u5F97\u5230 => build production\n  // pnpm dev:app \u65F6\u5F97\u5230 => build development (\u6CE8\u610F\u533A\u522B\uFF0Ccommand\u4E3Abuild)\n  // pnpm build:app \u65F6\u5F97\u5230 => build production\n  // dev \u548C build \u547D\u4EE4\u53EF\u4EE5\u5206\u522B\u4F7F\u7528 .env.development \u548C .env.production \u7684\u73AF\u5883\u53D8\u91CF\n\n  const { UNI_PLATFORM } = process.env\n  console.log('UNI_PLATFORM -> ', UNI_PLATFORM) // \u5F97\u5230 mp-weixin, h5, app \u7B49\n\n  const env = loadEnv(mode, path.resolve(process.cwd(), 'env'))\n  const {\n    VITE_APP_PORT,\n    VITE_SERVER_BASEURL,\n    VITE_APP_TITLE,\n    VITE_DELETE_CONSOLE,\n    VITE_APP_PUBLIC_BASE,\n    VITE_APP_PROXY_ENABLE,\n    VITE_APP_PROXY_PREFIX,\n    VITE_COPY_NATIVE_RES_ENABLE,\n  } = env\n  console.log('\u73AF\u5883\u53D8\u91CF env -> ', env)\n\n  return defineConfig({\n    envDir: './env', // \u81EA\u5B9A\u4E49env\u76EE\u5F55\n    base: VITE_APP_PUBLIC_BASE,\n    plugins: [\n      UniPages({\n        exclude: ['**/components/**/**.*'],\n        // pages \u76EE\u5F55\u4E3A src/pages\uFF0C\u5206\u5305\u76EE\u5F55\u4E0D\u80FD\u914D\u7F6E\u5728pages\u76EE\u5F55\u4E0B\uFF01\uFF01\n        // \u662F\u4E2A\u6570\u7EC4\uFF0C\u53EF\u4EE5\u914D\u7F6E\u591A\u4E2A\uFF0C\u4F46\u662F\u4E0D\u80FD\u4E3Apages\u91CC\u9762\u7684\u76EE\u5F55\uFF01\uFF01\n        subPackages: [\n          'src/pages-fg', // \u8FD9\u4E2A\u662F\u76F8\u5BF9\u5FC5\u8981\u7684\u8DEF\u7531\uFF0C\u5C3D\u91CF\u7559\u7740\uFF08\u767B\u5F55\u9875\u3001\u6CE8\u518C\u9875\u3001404\u9875\u7B49\uFF09\n          'src/pages-sub', // \u8FD9\u4E2A\u591A\u4E3A\u793A\u4F8B\u4EE3\u7801\uFF0C\u53C2\u8003\u7528\u7684\uFF0C\u5F00\u53D1\u5B8C\u540E\u6CE8\u91CA\u6389\u5373\u53EF\uFF08\u6216\u8005\u76F4\u63A5\u5220\u9664\uFF09\n        ],\n        dts: 'src/types/uni-pages.d.ts',\n      }),\n      UniLayouts(),\n      UniPlatform(),\n      UniManifest(),\n      // Optimization \u63D2\u4EF6\u9700\u8981 page.json \u6587\u4EF6\uFF0C\u6545\u5E94\u5728 UniPages \u63D2\u4EF6\u4E4B\u540E\u6267\u884C\n      Optimization({\n        enable: {\n          'optimization': true,\n          'async-import': true,\n          'async-component': true,\n        },\n        dts: {\n          base: 'src/types',\n        },\n        logger: false,\n      }),\n      // UniXXX \u9700\u8981\u5728 Uni \u4E4B\u524D\u5F15\u5165\n      {\n        // \u4E34\u65F6\u89E3\u51B3 dcloudio \u5B98\u65B9\u7684 @dcloudio/uni-mp-compiler \u51FA\u73B0\u7684\u7F16\u8BD1 BUG\n        // \u53C2\u8003 github issue: https://github.com/dcloudio/uni-app/issues/4952\n        // \u81EA\u5B9A\u4E49\u63D2\u4EF6\u7981\u7528 vite:vue \u63D2\u4EF6\u7684 devToolsEnabled\uFF0C\u5F3A\u5236\u7F16\u8BD1 vue \u6A21\u677F\u65F6 inline \u4E3A true\n        name: 'fix-vite-plugin-vue',\n        configResolved(config) {\n          const plugin = config.plugins.find(p => p.name === 'vite:vue')\n          if (plugin && plugin.api && plugin.api.options) {\n            plugin.api.options.devToolsEnabled = false\n          }\n        },\n      },\n      UnoCSS(),\n      AutoImport({\n        imports: ['vue', 'uni-app'],\n        dts: 'src/types/auto-import.d.ts',\n        dirs: ['src/hooks'], // \u81EA\u52A8\u5BFC\u5165 hooks\n        vueTemplate: true, // default false\n      }),\n      ViteRestart({\n        // \u901A\u8FC7\u8FD9\u4E2A\u63D2\u4EF6\uFF0C\u5728\u4FEE\u6539vite.config.js\u6587\u4EF6\u5219\u4E0D\u9700\u8981\u91CD\u65B0\u8FD0\u884C\u4E5F\u751F\u6548\u914D\u7F6E\n        restart: ['vite.config.js'],\n      }),\n      // h5\u73AF\u5883\u589E\u52A0 BUILD_TIME \u548C BUILD_BRANCH\n      UNI_PLATFORM === 'h5' && {\n        name: 'html-transform',\n        transformIndexHtml(html) {\n          return html.replace('%BUILD_TIME%', dayjs().format('YYYY-MM-DD HH:mm:ss')).replace('%VITE_APP_TITLE%', VITE_APP_TITLE)\n        },\n      },\n      // \u6253\u5305\u5206\u6790\u63D2\u4EF6\uFF0Ch5 + \u751F\u4EA7\u73AF\u5883\u624D\u5F39\u51FA\n      UNI_PLATFORM === 'h5'\n      && mode === 'production'\n      && visualizer({\n        filename: './node_modules/.cache/visualizer/stats.html',\n        open: true,\n        gzipSize: true,\n        brotliSize: true,\n      }),\n      // \u539F\u751F\u63D2\u4EF6\u8D44\u6E90\u590D\u5236\u63D2\u4EF6 - \u4EC5\u5728 app \u5E73\u53F0\u4E14\u542F\u7528\u65F6\u751F\u6548\n      createCopyNativeResourcesPlugin(\n        UNI_PLATFORM === 'app' && VITE_COPY_NATIVE_RES_ENABLE === 'true',\n        {\n          verbose: mode === 'development', // \u5F00\u53D1\u6A21\u5F0F\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7\n        },\n      ),\n      syncManifestPlugin(),\n      Components({\n        extensions: ['vue'],\n        deep: true, // \u662F\u5426\u9012\u5F52\u626B\u63CF\u5B50\u76EE\u5F55\uFF0C\n        directoryAsNamespace: false, // \u662F\u5426\u628A\u76EE\u5F55\u540D\u4F5C\u4E3A\u547D\u540D\u7A7A\u95F4\u524D\u7F00\uFF0Ctrue \u65F6\u7EC4\u4EF6\u540D\u4E3A \u76EE\u5F55\u540D+\u7EC4\u4EF6\u540D\uFF0C\n        dts: 'src/types/components.d.ts', // \u81EA\u52A8\u751F\u6210\u7684\u7EC4\u4EF6\u7C7B\u578B\u58F0\u660E\u6587\u4EF6\u8DEF\u5F84\uFF08\u7528\u4E8E TypeScript \u652F\u6301\uFF09\n      }),\n      // \u82E5\u5B58\u5728\u6539\u53D8 pages.json \u7684\u63D2\u4EF6\uFF0C\u8BF7\u5C06 UniKuRoot \u653E\u7F6E\u5176\u540E\n      UniKuRoot(),\n      Uni(),\n      // \u81EA\u52A8\u6253\u5F00\u5F00\u53D1\u8005\u5DE5\u5177\u63D2\u4EF6 (\u5FC5\u987B\u4FEE\u6539 .env \u6587\u4EF6\u4E2D\u7684 VITE_WX_APPID)\n      openDevTools(),\n    ],\n    define: {\n      __VITE_APP_PROXY__: JSON.stringify(VITE_APP_PROXY_ENABLE),\n    },\n    css: {\n      preprocessorOptions: {\n        scss: {\n          additionalData: `@import \"@/style/color.scss\";`,\n        },\n      },\n      postcss: {\n        plugins: [\n          // autoprefixer({\n          //   // \u6307\u5B9A\u76EE\u6807\u6D4F\u89C8\u5668\n          //   overrideBrowserslist: ['> 1%', 'last 2 versions'],\n          // }),\n        ],\n      },\n    },\n\n    resolve: {\n      alias: {\n        '@': path.join(process.cwd(), './src'),\n        '@img': path.join(process.cwd(), './src/static/images'),\n      },\n    },\n    server: {\n      host: '0.0.0.0',\n      hmr: true,\n      port: Number.parseInt(VITE_APP_PORT, 10),\n      // \u4EC5 H5 \u7AEF\u751F\u6548\uFF0C\u5176\u4ED6\u7AEF\u4E0D\u751F\u6548\uFF08\u5176\u4ED6\u7AEF\u8D70build\uFF0C\u4E0D\u8D70devServer)\n      proxy: JSON.parse(VITE_APP_PROXY_ENABLE)\n        ? {\n            [VITE_APP_PROXY_PREFIX]: {\n              target: VITE_SERVER_BASEURL,\n              changeOrigin: true,\n              // \u540E\u7AEF\u6709/api\u524D\u7F00\u5219\u4E0D\u505A\u5904\u7406\uFF0C\u6CA1\u6709\u5219\u9700\u8981\u53BB\u6389\n              rewrite: path => path.replace(new RegExp(`^${VITE_APP_PROXY_PREFIX}`), ''),\n            },\n          }\n        : undefined,\n    },\n    esbuild: {\n      drop: VITE_DELETE_CONSOLE === 'true' ? ['console'] : [],\n    },\n    build: {\n      sourcemap: false,\n      // \u65B9\u4FBF\u975Eh5\u7AEF\u8C03\u8BD5\n      // sourcemap: VITE_SHOW_SOURCEMAP === 'true', // \u9ED8\u8BA4\u662Ffalse\n      target: 'es6',\n      // \u5F00\u53D1\u73AF\u5883\u4E0D\u7528\u538B\u7F29\n      minify: mode === 'development' ? false : 'esbuild',\n    },\n  })\n})\n", "const __vite_injected_original_dirname = \"/Users/yrk/Desktop/ebike-ui\uFF08new\uFF09/ebike-plus-wx-maintenance/scripts\";const __vite_injected_original_filename = \"/Users/yrk/Desktop/ebike-ui\uFF08new\uFF09/ebike-plus-wx-maintenance/scripts/open-dev-tools.js\";const __vite_injected_original_import_meta_url = \"file:///Users/yrk/Desktop/ebike-ui%EF%BC%88new%EF%BC%89/ebike-plus-wx-maintenance/scripts/open-dev-tools.js\";import { exec } from 'node:child_process'\nimport fs from 'node:fs'\nimport path from 'node:path'\nimport process from 'node:process'\n\n/**\n * \u6253\u5F00\u5F00\u53D1\u8005\u5DE5\u5177\n */\nfunction _openDevTools() {\n  const platform = process.platform // darwin, win32, linux\n  const { UNI_PLATFORM } = process.env //  mp-weixin, mp-alipay\n\n  const uniPlatformText = UNI_PLATFORM === 'mp-weixin' ? '\u5FAE\u4FE1\u5C0F\u7A0B\u5E8F' : UNI_PLATFORM === 'mp-alipay' ? '\u652F\u4ED8\u5B9D\u5C0F\u7A0B\u5E8F' : '\u5C0F\u7A0B\u5E8F'\n\n  // \u9879\u76EE\u8DEF\u5F84\uFF08\u6784\u5EFA\u8F93\u51FA\u76EE\u5F55\uFF09\n  const projectPath = path.resolve(process.cwd(), `dist/dev/${UNI_PLATFORM}`)\n\n  // \u68C0\u67E5\u6784\u5EFA\u8F93\u51FA\u76EE\u5F55\u662F\u5426\u5B58\u5728\n  if (!fs.existsSync(projectPath)) {\n    console.log(`\u274C ${uniPlatformText}\u6784\u5EFA\u76EE\u5F55\u4E0D\u5B58\u5728:`, projectPath)\n    return\n  }\n\n  console.log(`\uD83D\uDE80 \u6B63\u5728\u6253\u5F00${uniPlatformText}\u5F00\u53D1\u8005\u5DE5\u5177...`)\n\n  // \u6839\u636E\u4E0D\u540C\u64CD\u4F5C\u7CFB\u7EDF\u6267\u884C\u4E0D\u540C\u547D\u4EE4\n  let command = ''\n\n  if (platform === 'darwin') {\n    // macOS\n    if (UNI_PLATFORM === 'mp-weixin') {\n      command = `/Applications/wechatwebdevtools.app/Contents/MacOS/cli -o \"${projectPath}\"`\n    }\n    else if (UNI_PLATFORM === 'mp-alipay') {\n      command = `/Applications/\u5C0F\u7A0B\u5E8F\u5F00\u53D1\u8005\u5DE5\u5177.app/Contents/MacOS/\u5C0F\u7A0B\u5E8F\u5F00\u53D1\u8005\u5DE5\u5177 --p \"${projectPath}\"`\n    }\n  }\n  else if (platform === 'win32' || platform === 'win64') {\n    // Windows\n    if (UNI_PLATFORM === 'mp-weixin') {\n      command = `\"C:\\\\Program Files (x86)\\\\Tencent\\\\\u5FAE\u4FE1web\u5F00\u53D1\u8005\u5DE5\u5177\\\\cli.bat\" -o \"${projectPath}\"`\n    }\n  }\n  else {\n    // Linux \u6216\u5176\u4ED6\u7CFB\u7EDF\n    console.log('\u274C \u5F53\u524D\u7CFB\u7EDF\u4E0D\u652F\u6301\u81EA\u52A8\u6253\u5F00\u5FAE\u4FE1\u5F00\u53D1\u8005\u5DE5\u5177')\n    return\n  }\n\n  exec(command, (error, stdout, stderr) => {\n    if (error) {\n      console.log(`\u274C \u6253\u5F00${uniPlatformText}\u5F00\u53D1\u8005\u5DE5\u5177\u5931\u8D25:`, error.message)\n      console.log(`\uD83D\uDCA1 \u8BF7\u786E\u4FDD${uniPlatformText}\u5F00\u53D1\u8005\u5DE5\u5177\u670D\u52A1\u7AEF\u53E3\u5DF2\u542F\u7528`)\n      console.log(`\uD83D\uDCA1 \u53EF\u4EE5\u624B\u52A8\u6253\u5F00${uniPlatformText}\u5F00\u53D1\u8005\u5DE5\u5177\u5E76\u5BFC\u5165\u9879\u76EE:`, projectPath)\n      return\n    }\n\n    if (stderr) {\n      console.log('\u26A0\uFE0F \u8B66\u544A:', stderr)\n    }\n\n    console.log(`\u2705 ${uniPlatformText}\u5F00\u53D1\u8005\u5DE5\u5177\u5DF2\u6253\u5F00`)\n\n    if (stdout) {\n      console.log(stdout)\n    }\n  })\n}\n\nexport default function openDevTools() {\n  // \u9996\u6B21\u6784\u5EFA\u6807\u8BB0\n  let isFirstBuild = true\n\n  return {\n    name: 'uni-devtools',\n    writeBundle() {\n      if (isFirstBuild && process.env.UNI_PLATFORM?.includes('mp')) {\n        isFirstBuild = false\n        _openDevTools()\n      }\n    },\n  }\n}\n", "const __vite_injected_original_dirname = \"/Users/yrk/Desktop/ebike-ui\uFF08new\uFF09/ebike-plus-wx-maintenance/vite-plugins\";const __vite_injected_original_filename = \"/Users/yrk/Desktop/ebike-ui\uFF08new\uFF09/ebike-plus-wx-maintenance/vite-plugins/copy-native-resources.ts\";const __vite_injected_original_import_meta_url = \"file:///Users/yrk/Desktop/ebike-ui%EF%BC%88new%EF%BC%89/ebike-plus-wx-maintenance/vite-plugins/copy-native-resources.ts\";import type { Plugin } from 'vite'\nimport path from 'node:path'\nimport process from 'node:process'\nimport fs from 'fs-extra'\n\n/**\n * \u539F\u751F\u63D2\u4EF6\u8D44\u6E90\u590D\u5236\u914D\u7F6E\u63A5\u53E3\n *\n * \u6839\u636E UniApp \u5B98\u65B9\u6587\u6863\uFF1Ahttps://uniapp.dcloud.net.cn/plugin/native-plugin.html#%E6%9C%AC%E5%9C%B0%E6%8F%92%E4%BB%B6-%E9%9D%9E%E5%86%85%E7%BD%AE%E5%8E%9F%E7%94%9F%E6%8F%92%E4%BB%B6\n * \u672C\u5730\u63D2\u4EF6\u5E94\u8BE5\u5B58\u50A8\u5728\u9879\u76EE\u6839\u76EE\u5F55\u7684 nativeplugins \u76EE\u5F55\u4E0B\n */\nexport interface CopyNativeResourcesOptions {\n  /** \u662F\u5426\u542F\u7528\u63D2\u4EF6 */\n  enable?: boolean\n  /**\n   * \u6E90\u76EE\u5F55\u8DEF\u5F84\uFF0C\u76F8\u5BF9\u4E8E\u9879\u76EE\u6839\u76EE\u5F55\n   * \u9ED8\u8BA4\u4E3A 'nativeplugins'\uFF0C\u7B26\u5408 UniApp \u5B98\u65B9\u89C4\u8303\n   * @see https://uniapp.dcloud.net.cn/plugin/native-plugin.html#%E6%9C%AC%E5%9C%B0%E6%8F%92%E4%BB%B6-%E9%9D%9E%E5%86%85%E7%BD%AE%E5%8E%9F%E7%94%9F%E6%8F%92%E4%BB%B6\n   */\n  sourceDir?: string\n  /**\n   * \u76EE\u6807\u76EE\u5F55\u540D\u79F0\uFF0C\u6784\u5EFA\u540E\u5728 dist \u76EE\u5F55\u4E2D\u7684\u6587\u4EF6\u5939\u540D\n   * \u9ED8\u8BA4\u4E3A 'nativeplugins'\uFF0C\u4E0E\u6E90\u76EE\u5F55\u4FDD\u6301\u4E00\u81F4\n   */\n  targetDirName?: string\n  /** \u662F\u5426\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7\uFF0C\u4FBF\u4E8E\u8C03\u8BD5\u548C\u76D1\u63A7\u590D\u5236\u8FC7\u7A0B */\n  verbose?: boolean\n  /** \u81EA\u5B9A\u4E49\u65E5\u5FD7\u524D\u7F00\uFF0C\u7528\u4E8E\u533A\u5206\u4E0D\u540C\u63D2\u4EF6\u7684\u65E5\u5FD7\u8F93\u51FA */\n  logPrefix?: string\n}\n\n/**\n * \u9ED8\u8BA4\u914D\u7F6E\n *\n * \u6839\u636E UniApp \u5B98\u65B9\u6587\u6863\u89C4\u8303\u8BBE\u7F6E\u9ED8\u8BA4\u503C\uFF1A\n * - sourceDir: 'nativeplugins' - \u7B26\u5408\u5B98\u65B9\u672C\u5730\u63D2\u4EF6\u5B58\u50A8\u89C4\u8303\n * - targetDirName: 'nativeplugins' - \u6784\u5EFA\u540E\u4FDD\u6301\u76F8\u540C\u7684\u76EE\u5F55\u7ED3\u6784\n */\nconst DEFAULT_OPTIONS: Required<CopyNativeResourcesOptions> = {\n  enable: true,\n  sourceDir: 'nativeplugins',\n  targetDirName: 'nativeplugins',\n  verbose: true,\n  logPrefix: '[copy-native-resources]',\n}\n\n/**\n * UniApp \u539F\u751F\u63D2\u4EF6\u8D44\u6E90\u590D\u5236\u63D2\u4EF6\n *\n * \u529F\u80FD\u8BF4\u660E\uFF1A\n * 1. \u89E3\u51B3 UniApp \u4F7F\u7528\u672C\u5730\u539F\u751F\u63D2\u4EF6\u65F6\uFF0C\u6253\u5305\u540E\u539F\u751F\u63D2\u4EF6\u8D44\u6E90\u627E\u4E0D\u5230\u7684\u95EE\u9898\n * 2. \u5C06\u9879\u76EE\u6839\u76EE\u5F55\u4E0B\u7684 nativeplugins \u76EE\u5F55\u590D\u5236\u5230\u6784\u5EFA\u8F93\u51FA\u76EE\u5F55\u4E2D\n * 3. \u652F\u6301 Android \u548C iOS \u5E73\u53F0\u7684\u539F\u751F\u63D2\u4EF6\u8D44\u6E90\u590D\u5236\n * 4. \u4EC5\u5728 app \u5E73\u53F0\u6784\u5EFA\u65F6\u751F\u6548\uFF0C\u5176\u4ED6\u5E73\u53F0\uFF08H5\u3001\u5C0F\u7A0B\u5E8F\uFF09\u4E0D\u6267\u884C\n *\n * \u4F7F\u7528\u573A\u666F\uFF1A\n * - \u4F7F\u7528\u4E86 UniApp \u672C\u5730\u539F\u751F\u63D2\u4EF6\uFF08\u975E\u4E91\u7AEF\u63D2\u4EF6\uFF09\n * - \u539F\u751F\u63D2\u4EF6\u5305\u542B\u989D\u5916\u7684\u8D44\u6E90\u6587\u4EF6\uFF08\u5982 .so \u5E93\u6587\u4EF6\u3001\u914D\u7F6E\u6587\u4EF6\u7B49\uFF09\n * - \u9700\u8981\u5728\u6253\u5305\u540E\u4FDD\u6301\u539F\u751F\u63D2\u4EF6\u7684\u5B8C\u6574\u76EE\u5F55\u7ED3\u6784\n *\n * \u5B98\u65B9\u6587\u6863\u53C2\u8003\uFF1A\n * @see https://uniapp.dcloud.net.cn/plugin/native-plugin.html#%E6%9C%AC%E5%9C%B0%E6%8F%92%E4%BB%B6-%E9%9D%9E%E5%86%85%E7%BD%AE%E5%8E%9F%E7%94%9F%E6%8F%92%E4%BB%B6\n * @see https://uniapp.dcloud.net.cn/tutorial/nvue-api.html#dom\n *\n * @param options \u63D2\u4EF6\u914D\u7F6E\u9009\u9879\n * @returns Vite \u63D2\u4EF6\u5BF9\u8C61\n */\nexport function copyNativeResources(options: CopyNativeResourcesOptions = {}): Plugin {\n  const config = { ...DEFAULT_OPTIONS, ...options }\n\n  // \u5982\u679C\u63D2\u4EF6\u88AB\u7981\u7528\uFF0C\u8FD4\u56DE\u4E00\u4E2A\u7A7A\u63D2\u4EF6\n  if (!config.enable) {\n    return {\n      name: 'copy-native-resources-disabled',\n      apply: 'build',\n      writeBundle() {\n        // \u63D2\u4EF6\u5DF2\u7981\u7528\uFF0C\u4E0D\u6267\u884C\u4EFB\u4F55\u64CD\u4F5C\n      },\n    }\n  }\n\n  return {\n    name: 'copy-native-resources',\n    apply: 'build', // \u53EA\u5728\u6784\u5EFA\u65F6\u5E94\u7528\n    enforce: 'post', // \u5728\u5176\u4ED6\u63D2\u4EF6\u6267\u884C\u5B8C\u6BD5\u540E\u6267\u884C\n\n    async writeBundle() {\n      const { sourceDir, targetDirName, verbose, logPrefix } = config\n\n      try {\n        // \u83B7\u53D6\u9879\u76EE\u6839\u76EE\u5F55\u8DEF\u5F84\n        const projectRoot = process.cwd()\n\n        // \u6784\u5EFA\u6E90\u76EE\u5F55\u7EDD\u5BF9\u8DEF\u5F84\uFF08\u9879\u76EE\u6839\u76EE\u5F55\u4E0B\u7684 nativeplugins \u76EE\u5F55\uFF09\n        const sourcePath = path.resolve(projectRoot, sourceDir)\n\n        // \u6784\u5EFA\u76EE\u6807\u8DEF\u5F84\uFF1Adist/[build|dev]/[platform]/nativeplugins\n        // buildMode: 'build' (\u751F\u4EA7\u73AF\u5883) \u6216 'dev' (\u5F00\u53D1\u73AF\u5883)\n        // platform: 'app' (App\u5E73\u53F0) \u6216\u5176\u4ED6\u5E73\u53F0\u6807\u8BC6\n        const buildMode = process.env.NODE_ENV === 'production' ? 'build' : 'dev'\n        const platform = process.env.UNI_PLATFORM || 'app'\n        const targetPath = path.resolve(\n          projectRoot,\n          'dist',\n          buildMode,\n          platform,\n          targetDirName,\n        )\n\n        // \u68C0\u67E5\u6E90\u76EE\u5F55\u662F\u5426\u5B58\u5728\n        // \u5982\u679C\u4E0D\u5B58\u5728 nativeplugins \u76EE\u5F55\uFF0C\u8BF4\u660E\u9879\u76EE\u6CA1\u6709\u4F7F\u7528\u672C\u5730\u539F\u751F\u63D2\u4EF6\n        const sourceExists = await fs.pathExists(sourcePath)\n        if (!sourceExists) {\n          if (verbose) {\n            console.warn(`${logPrefix} \u6E90\u76EE\u5F55\u4E0D\u5B58\u5728\uFF0C\u8DF3\u8FC7\u590D\u5236\u64CD\u4F5C`)\n            console.warn(`${logPrefix} \u6E90\u76EE\u5F55\u8DEF\u5F84: ${sourcePath}`)\n            console.warn(`${logPrefix} \u5982\u9700\u4F7F\u7528\u672C\u5730\u539F\u751F\u63D2\u4EF6\uFF0C\u8BF7\u5728\u9879\u76EE\u6839\u76EE\u5F55\u521B\u5EFA nativeplugins \u76EE\u5F55`)\n            console.warn(`${logPrefix} \u5E76\u6309\u7167\u5B98\u65B9\u6587\u6863\u653E\u5165\u539F\u751F\u63D2\u4EF6\u6587\u4EF6`)\n            console.warn(`${logPrefix} \u53C2\u8003: https://uniapp.dcloud.net.cn/plugin/native-plugin.html`)\n          }\n          return\n        }\n\n        // \u68C0\u67E5\u6E90\u76EE\u5F55\u662F\u5426\u4E3A\u7A7A\n        // \u5982\u679C\u76EE\u5F55\u5B58\u5728\u4F46\u4E3A\u7A7A\uFF0C\u4E5F\u8DF3\u8FC7\u590D\u5236\u64CD\u4F5C\n        const sourceFiles = await fs.readdir(sourcePath)\n        if (sourceFiles.length === 0) {\n          if (verbose) {\n            console.warn(`${logPrefix} \u6E90\u76EE\u5F55\u4E3A\u7A7A\uFF0C\u8DF3\u8FC7\u590D\u5236\u64CD\u4F5C`)\n            console.warn(`${logPrefix} \u6E90\u76EE\u5F55\u8DEF\u5F84: ${sourcePath}`)\n            console.warn(`${logPrefix} \u8BF7\u5728 nativeplugins \u76EE\u5F55\u4E2D\u653E\u5165\u539F\u751F\u63D2\u4EF6\u6587\u4EF6`)\n          }\n          return\n        }\n\n        // \u786E\u4FDD\u76EE\u6807\u76EE\u5F55\u53CA\u5176\u7236\u76EE\u5F55\u5B58\u5728\n        await fs.ensureDir(targetPath)\n\n        if (verbose) {\n          console.log(`${logPrefix} \u5F00\u59CB\u590D\u5236 UniApp \u672C\u5730\u539F\u751F\u63D2\u4EF6...`)\n          console.log(`${logPrefix} \u6E90\u76EE\u5F55: ${sourcePath}`)\n          console.log(`${logPrefix} \u76EE\u6807\u76EE\u5F55: ${targetPath}`)\n          console.log(`${logPrefix} \u6784\u5EFA\u6A21\u5F0F: ${buildMode}`)\n          console.log(`${logPrefix} \u76EE\u6807\u5E73\u53F0: ${platform}`)\n          console.log(`${logPrefix} \u53D1\u73B0 ${sourceFiles.length} \u4E2A\u539F\u751F\u63D2\u4EF6\u6587\u4EF6/\u76EE\u5F55`)\n        }\n\n        // \u6267\u884C\u6587\u4EF6\u590D\u5236\u64CD\u4F5C\n        // \u5C06\u6574\u4E2A nativeplugins \u76EE\u5F55\u590D\u5236\u5230\u6784\u5EFA\u8F93\u51FA\u76EE\u5F55\n        await fs.copy(sourcePath, targetPath, {\n          overwrite: true, // \u8986\u76D6\u5DF2\u5B58\u5728\u7684\u6587\u4EF6\uFF0C\u786E\u4FDD\u4F7F\u7528\u6700\u65B0\u7248\u672C\n          errorOnExist: false, // \u5982\u679C\u76EE\u6807\u6587\u4EF6\u5B58\u5728\u4E0D\u62A5\u9519\n          preserveTimestamps: true, // \u4FDD\u6301\u6587\u4EF6\u7684\u65F6\u95F4\u6233\n        })\n\n        if (verbose) {\n          console.log(`${logPrefix} \u2705 UniApp \u672C\u5730\u539F\u751F\u63D2\u4EF6\u590D\u5236\u5B8C\u6210`)\n          console.log(`${logPrefix} \u5DF2\u6210\u529F\u590D\u5236 ${sourceFiles.length} \u4E2A\u6587\u4EF6/\u76EE\u5F55\u5230\u6784\u5EFA\u76EE\u5F55`)\n          console.log(`${logPrefix} \u539F\u751F\u63D2\u4EF6\u73B0\u5728\u53EF\u4EE5\u5728 App \u4E2D\u6B63\u5E38\u4F7F\u7528`)\n        }\n      }\n      catch (error) {\n        console.error(`${config.logPrefix} \u274C \u590D\u5236 UniApp \u672C\u5730\u539F\u751F\u63D2\u4EF6\u5931\u8D25:`, error)\n        console.error(`${config.logPrefix} \u9519\u8BEF\u8BE6\u60C5:`, error instanceof Error ? error.message : String(error))\n        console.error(`${config.logPrefix} \u8BF7\u68C0\u67E5\u6E90\u76EE\u5F55\u6743\u9650\u548C\u78C1\u76D8\u7A7A\u95F4`)\n        // \u4E0D\u629B\u51FA\u9519\u8BEF\uFF0C\u907F\u514D\u5F71\u54CD\u6574\u4E2A\u6784\u5EFA\u8FC7\u7A0B\uFF0C\u4F46\u4F1A\u8BB0\u5F55\u8BE6\u7EC6\u7684\u9519\u8BEF\u4FE1\u606F\n      }\n    },\n  }\n}\n\n/**\n * \u521B\u5EFA UniApp \u672C\u5730\u539F\u751F\u63D2\u4EF6\u8D44\u6E90\u590D\u5236\u63D2\u4EF6\u7684\u4FBF\u6377\u51FD\u6570\n *\n * \u8FD9\u662F\u4E00\u4E2A\u4FBF\u6377\u7684\u5DE5\u5382\u51FD\u6570\uFF0C\u7528\u4E8E\u5FEB\u901F\u521B\u5EFA\u63D2\u4EF6\u5B9E\u4F8B\n * \u7279\u522B\u9002\u7528\u4E8E\u5728 vite.config.ts \u4E2D\u8FDB\u884C\u6761\u4EF6\u6027\u63D2\u4EF6\u914D\u7F6E\n *\n * \u4F7F\u7528\u793A\u4F8B\uFF1A\n * ```typescript\n * // \u5728 vite.config.ts \u4E2D\n * plugins: [\n *   // \u4EC5\u5728 app \u5E73\u53F0\u4E14\u542F\u7528\u65F6\u751F\u6548\n *   UNI_PLATFORM === 'app'\n *     ? createCopyNativeResourcesPlugin(\n *         VITE_COPY_NATIVE_RES_ENABLE === 'true',\n *         { verbose: mode === 'development' }\n *       )\n *     : null,\n * ]\n * ```\n *\n * @param enable \u662F\u5426\u542F\u7528\u63D2\u4EF6\uFF0C\u901A\u5E38\u901A\u8FC7\u73AF\u5883\u53D8\u91CF\u63A7\u5236\n * @param options \u5176\u4ED6\u914D\u7F6E\u9009\u9879\uFF0C\u4E0D\u5305\u542B enable \u5C5E\u6027\n * @returns Vite \u63D2\u4EF6\u5BF9\u8C61\n */\nexport function createCopyNativeResourcesPlugin(\n  enable: boolean = true,\n  options: Omit<CopyNativeResourcesOptions, 'enable'> = {},\n): Plugin {\n  return copyNativeResources({ enable, ...options })\n}\n", "const __vite_injected_original_dirname = \"/Users/yrk/Desktop/ebike-ui\uFF08new\uFF09/ebike-plus-wx-maintenance/vite-plugins\";const __vite_injected_original_filename = \"/Users/yrk/Desktop/ebike-ui\uFF08new\uFF09/ebike-plus-wx-maintenance/vite-plugins/sync-manifest-plugins.ts\";const __vite_injected_original_import_meta_url = \"file:///Users/yrk/Desktop/ebike-ui%EF%BC%88new%EF%BC%89/ebike-plus-wx-maintenance/vite-plugins/sync-manifest-plugins.ts\";import type { Plugin } from 'vite'\nimport fs from 'node:fs'\nimport path from 'node:path'\nimport process from 'node:process'\n\ninterface ManifestType {\n  'plus'?: {\n    distribute?: {\n      plugins?: Record<string, any>\n    }\n  }\n  'app-plus'?: {\n    distribute?: {\n      plugins?: Record<string, any>\n    }\n  }\n}\n\nexport default function syncManifestPlugin(): Plugin {\n  return {\n    name: 'sync-manifest',\n    apply: 'build',\n    enforce: 'post',\n    writeBundle: {\n      order: 'post',\n      handler() {\n        const srcManifestPath = path.resolve(process.cwd(), './src/manifest.json')\n        const distAppPath = path.resolve(process.cwd(), './dist/dev/app/manifest.json')\n\n        try {\n          // \u8BFB\u53D6\u6E90\u6587\u4EF6\n          const srcManifest = JSON.parse(fs.readFileSync(srcManifestPath, 'utf8')) as ManifestType\n\n          // \u786E\u4FDD\u76EE\u6807\u76EE\u5F55\u5B58\u5728\n          const distAppDir = path.dirname(distAppPath)\n          if (!fs.existsSync(distAppDir)) {\n            fs.mkdirSync(distAppDir, { recursive: true })\n          }\n\n          // \u8BFB\u53D6\u76EE\u6807\u6587\u4EF6\uFF08\u5982\u679C\u5B58\u5728\uFF09\n          let distManifest: ManifestType = {}\n          if (fs.existsSync(distAppPath)) {\n            distManifest = JSON.parse(fs.readFileSync(distAppPath, 'utf8'))\n          }\n\n          // \u5982\u679C\u6E90\u6587\u4EF6\u5B58\u5728 plugins\n          if (srcManifest['app-plus']?.distribute?.plugins) {\n            // \u786E\u4FDD\u76EE\u6807\u6587\u4EF6\u4E2D\u6709\u5FC5\u8981\u7684\u5BF9\u8C61\u7ED3\u6784\n            if (!distManifest.plus)\n              distManifest.plus = {}\n            if (!distManifest.plus.distribute)\n              distManifest.plus.distribute = {}\n\n            // \u590D\u5236 plugins \u5185\u5BB9\n            distManifest.plus.distribute.plugins = srcManifest['app-plus'].distribute.plugins\n\n            // \u5199\u5165\u66F4\u65B0\u540E\u7684\u5185\u5BB9\n            fs.writeFileSync(distAppPath, JSON.stringify(distManifest, null, 2))\n            console.log('\u2705 Manifest plugins \u540C\u6B65\u6210\u529F')\n          }\n        }\n        catch (error) {\n          console.error('\u274C \u540C\u6B65 manifest plugins \u5931\u8D25:', error)\n        }\n      },\n    },\n  }\n}\n"],
  "mappings": "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",
  "names": ["path", "process", "path", "process", "fs", "process", "path", "fs", "fs", "path", "process", "path", "process", "fs", "process", "path"]
}
