adtec-core-package 0.3.1 → 0.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adtec-core-package",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "private": false,
   "type": "module",
   "scripts": {

package/src/components/Search/ElSearch.vue

@@ -45,14 +45,16 @@ const is_retract = ref(false)
 const ref_div = ref()
 const windowContent = useWindowSize()
 const collapsed = inject<boolean>('collapsed')
-const collapsedSearch=ref<boolean|undefined>(false)
+const collapsedSearch=ref<boolean>(false)
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 //@ts-expect-error
 watch(collapsed, () => {
-  collapsedSearch.value = collapsed
-  calculation()
+  //@ts-ignore
+  collapsedSearch.value = collapsed.value
+  // calculation()
 })
 watch(collapsedSearch, () => {
+  console.log("collapsedSearch")
   calculation()
 })
 watch(windowContent.width, () => {
@@ -110,7 +112,9 @@ const emit = defineEmits<{
   (event: 'search'): void
 }>()
 onMounted(() => {
-  collapsedSearch.value = collapsed
+  //ts-ignore
+  //@ts-expect-error
+  collapsedSearch.value = collapsed.value
   //@ts-ignore
   window.$wujie?.bus.$on("collapsedChangeBus", (val:boolean) => {
     collapsedSearch.value=val

package/src/hooks/useDictHooks.ts

@@ -1,36 +1,40 @@
+import { storeToRefs } from 'pinia'
 import { ElMessage } from 'element-plus'
 import SysDictCacheApi from '../api/SysDictCacheApi'
 import type { ISysDictDataCacheVo } from '../interface/ISysDictDataCacheVo'
-import { type dictDataMapVoType, dictStore } from '../stores/dictStore'
+import { dictStore } from '../stores/dictStore'
 
-export default function useDictHooks(dictTypes: string[]) {
+export default function useDictHooks(dictTypes?: string[]) {
   const dictStores = dictStore()
-
+  const { dictMap, dictDefaultValueMap } = storeToRefs(dictStores)
   const getDict = async (dictTypes: string[]) => {
     try {
-      //判断是否存在缓存数据，如果存在则不请求接口
+      if (!dictTypes || !dictTypes.length) return
+      // 判断是否存在缓存数据，如果存在则不请求接口
       const dictKeySet = new Set(Object.keys(dictStores.dictMap))
       const uncachedDictTypes = dictTypes.filter((dictType) => !dictKeySet.has(dictType))
-      if (uncachedDictTypes.length) {
-        const data = await SysDictCacheApi.batchGetSysDictDataCacheVo(dictTypes)
-        dictStores.dictMap = { ...dictStores.dictMap, ...data }
-        // 获取默认值
-        Object.keys(data).forEach((item: string) => {
-          findDefaultValue(data[item], item)
-          const dataMap: dictDataMapVoType = {}
-          packageDictDataMap(dataMap, data[item])
-          dictStores.dictDataMap[item] = dataMap
-        })
-      }
+      if (!uncachedDictTypes.length) return
+      const data = await SysDictCacheApi.batchGetSysDictDataCacheVo(uncachedDictTypes)
+      dictStores.dictMap = { ...dictStores.dictMap, ...data }
+      // 获取默认值
+      Object.keys(data).forEach((item: string) => {
+        findDefaultValue(data[item], item)
+        const dataMap = new Map<string, ISysDictDataCacheVo>()
+        packageDictDataMap(dataMap, data[item])
+        dictStores.dictDataMap.set(item, dataMap)
+      })
     } catch (error: any) {
       ElMessage.error(error.msg || error.message)
     }
   }
 
-  const packageDictDataMap = async (map: dictDataMapVoType, list?: ISysDictDataCacheVo[]) => {
+  const packageDictDataMap = async (
+    map: Map<string, ISysDictDataCacheVo>,
+    list?: ISysDictDataCacheVo[],
+  ) => {
     if (list && list.length) {
       list.forEach((item: ISysDictDataCacheVo) => {
-        map[item.value] = { ...item, ...{ children: undefined } }
+        map.set(item.value, { ...item, ...{ children: undefined } })
         packageDictDataMap(map, item.children)
       })
     }
@@ -38,9 +42,7 @@ export default function useDictHooks(dictTypes: string[]) {
 
   const findDefaultValue = async (list: ISysDictDataCacheVo[], type: string) => {
     const find = getDefaultValue(list)
-    if (find) {
-      dictStores.dictDefaultValueMap[type] = find
-    }
+    find && dictStores.dictDefaultValueMap.set(type, find)
   }
 
   const getDefaultValue = (list?: ISysDictDataCacheVo[]): ISysDictDataCacheVo | undefined => {
@@ -55,21 +57,18 @@ export default function useDictHooks(dictTypes: string[]) {
   }
 
   const getDictName = (value?: string, dictType?: string) => {
-    if (dictStores.dictDataMap[dictType!]) {
-      return dictStores.dictDataMap[dictType!][value!]?.label || value
-    }
-    return value
+    return dictStores.dictDataMap.get(dictType!)?.get(value!)?.label || value
   }
 
   const getDictData = (value: string, dictType: string) => {
-    return dictStores.dictDataMap[dictType!][value!]
+    return dictStores.dictDataMap.get(dictType)?.get(value)
+  }
+  if (dictTypes && dictTypes.length) {
+    getDict(dictTypes).then(() => {})
   }
-
-  getDict(dictTypes).then(() => {})
-
   return {
-    dictMap: dictStores.dictMap,
-    dictDefaultValueMap: dictStores.dictDefaultValueMap,
+    dictMap,
+    dictDefaultValueMap,
     getDict,
     getDictName,
     getDictData,

package/src/hooks/useResetRefHooks.ts

@@ -1,5 +1,4 @@
 import { type Ref, ref } from 'vue'
-import { cloneDeep } from 'lodash-es'
 
 /**
  * 创建人 胡啸东
@@ -9,10 +8,10 @@ import { cloneDeep } from 'lodash-es'
  */
 
 export function useResetRefHooks<T>(value: T): [Ref<T>, () => void] {
-  const initValue = cloneDeep(value)
+  const initValue = JSON.parse(JSON.stringify(value))
   const state = ref(value)
   const reset = () => {
-    state.value = cloneDeep(initValue)
+    state.value = JSON.parse(JSON.stringify(initValue))
   }
   //@ts-ignore
   return [state, reset]

package/src/stores/dictStore.ts

@@ -7,18 +7,11 @@ export interface dictMapType {
   [key: string]: ISysDictDataCacheVo[]
 }
 
-export interface dictDataMapVoType {
-  [key: string]: ISysDictDataCacheVo
-}
-
-export interface dictDataMapType {
-  [key: string]: { [key: string]: ISysDictDataCacheVo }
-}
-
 export const dictStore = defineStore('dictStore', () => {
   const dictMap = ref<dictMapType>({})
-  const dictDataMap = ref<dictDataMapType>({})
-  const dictDefaultValueMap = ref<dictDataMapVoType>({})
+  const dictDataMap = ref<Map<string, Map<string, ISysDictDataCacheVo>>>(new Map())
+  const dictDefaultValueMap = ref<Map<string, ISysDictDataCacheVo>>(new Map())
+
   return {
     dictMap,
     dictDataMap,