adtec-core-package 3.2.9 → 3.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adtec-core-package",
-  "version": "3.2.9",
+  "version": "3.3.1",
   "private": false,
   "type": "module",
   "exports": {
@@ -102,6 +102,7 @@
     "smooth-signature": "1.0.15",
     "socket.io-client": "^2.3.1",
     "tdesign-vue-next": "1.18.2",
+    "ts-md5": "^1.3.1",
     "uuid": "^11.0.3",
     "vue": "^3.5.13",
     "vue-demi": "^0.14.10",

package/src/config/ElementPlusConfig.ts

@@ -82,6 +82,28 @@ ElSelect.props.fitInputWidth = {
   type: Boolean,
   default: false,
 }
+const isWujieSubApp =
+  typeof window !== 'undefined' && !!(window as Window & { __POWERED_BY_WUJIE__?: boolean }).__POWERED_BY_WUJIE__
+/**
+ * 无界 iframe 内 Popper 坐标修正。
+ * ElSelect / ElDatePicker 等须保持 teleported 默认 true（vxe 单元格挂 body + popperClass 防 clearEdit），
+ * 仅通过 strategy/modifiers 修正偏移，避免各子应用逐页 v-bind。
+ */
+const wujiePopperOptions = {
+  strategy: 'fixed' as const,
+  modifiers: [
+    {
+      name: 'computeStyles',
+      options: { adaptive: false, gpuAcceleration: false },
+    },
+  ],
+}
+if (isWujieSubApp) {
+  ElSelect.props.popperOptions = { type: Object, default: () => wujiePopperOptions }
+  ElDatePicker.props.popperOptions = { type: Object, default: () => wujiePopperOptions }
+  ElTreeSelect.props.popperOptions = { type: Object, default: () => wujiePopperOptions }
+  ElCascader.props.popperOptions = { type: Object, default: () => wujiePopperOptions }
+}
 ElSelect.props.popperClass = {
   type: String,
   default: VXE_IGNORE_CLEAR_POPPER,

package/src/hooks/useDictHooks.ts

@@ -7,6 +7,39 @@ import { storeToRefs } from 'pinia'
 import { userInfoStore } from '../stores/userInfoStore.ts'
 import frameworkUtils from '../utils/FrameworkUtils.ts'
 
+/**
+ * 后端在带 orgId 且 Redis 未命中时，可能返回带 parentId 的扁平列表（未 buildTree）。
+ * 前端按 parentId 重建 children，恢复领域/项目类型等树形字典。
+ */
+const ensureDictTree = (list?: ISysDictDataCacheVo[]): ISysDictDataCacheVo[] => {
+  if (!list?.length) return list ?? []
+  if (list.some((item) => Array.isArray(item.children) && item.children.length > 0)) {
+    return list
+  }
+  const nodeMap = new Map<string, ISysDictDataCacheVo>()
+  list.forEach((item) => {
+    if (!item?.id) return
+    nodeMap.set(item.id, { ...item, children: undefined })
+  })
+  if (!nodeMap.size) return list
+
+  const roots: ISysDictDataCacheVo[] = []
+  let linked = 0
+  nodeMap.forEach((node) => {
+    const parentId = node.parentId
+    if (parentId && parentId !== '0' && nodeMap.has(parentId)) {
+      const parent = nodeMap.get(parentId)!
+      if (!parent.children) parent.children = []
+      parent.children.push(node)
+      linked += 1
+    } else {
+      roots.push(node)
+    }
+  })
+  if (!linked) return list
+  return roots
+}
+
 export default function useDictHooks(dictTypes?: string[], orgId?: string) {
   const userInfo = userInfoStore()
   const dictStores = dictStore()
@@ -19,37 +52,133 @@ export default function useDictHooks(dictTypes?: string[], orgId?: string) {
     return userInfo.user?.orgId
   }
 
+  const hasDictList = (list?: ISysDictDataCacheVo[]) => Array.isArray(list) && list.length > 0
+
+  const hasDictCache = (dictType: string, oid?: string): boolean => {
+    if (oid && hasDictList(dictMap.value[`${oid}:${dictType}`])) return true
+    if (hasDictList(dictMap.value[dictType])) return true
+    return Object.keys(dictMap.value).some(
+      (key) => key.endsWith(`:${dictType}`) && hasDictList(dictMap.value[key]),
+    )
+  }
+
+  const resolveDictMapKey = (dictType: string, orgId?: string): string | undefined => {
+    const tenantOrgId = resolveOrgId()
+    const scopedOrgId = orgId ?? tenantOrgId
+    if (scopedOrgId && hasDictList(dictMap.value[`${scopedOrgId}:${dictType}`])) {
+      return `${scopedOrgId}:${dictType}`
+    }
+    if (hasDictList(dictMap.value[dictType])) return dictType
+    const fallback = Object.keys(dictMap.value).find(
+      (key) => key.endsWith(`:${dictType}`) && hasDictList(dictMap.value[key]),
+    )
+    return fallback
+  }
+
+  const resolveDictDataKey = (dictType: string, orgId?: string): string | undefined => {
+    const tenantOrgId = resolveOrgId()
+    const scopedOrgId = orgId ?? tenantOrgId
+    if (scopedOrgId) {
+      const scopedKey = `${scopedOrgId}:${dictType}`
+      if (dictDataMap.value[scopedKey] && Object.keys(dictDataMap.value[scopedKey]).length) {
+        return scopedKey
+      }
+    }
+    if (dictDataMap.value[dictType] && Object.keys(dictDataMap.value[dictType]).length) {
+      return dictType
+    }
+    return Object.keys(dictDataMap.value).find(
+      (key) => key.endsWith(`:${dictType}`) && Object.keys(dictDataMap.value[key]).length > 0,
+    )
+  }
+
+  const repairCachedDictTrees = (): boolean => {
+    let repaired = false
+    for (const key of Object.keys(dictMap.value)) {
+      const list = dictMap.value[key]
+      if (!hasDictList(list)) continue
+      const tree = ensureDictTree(list)
+      if (tree !== list && tree.some((item) => item.children?.length)) {
+        dictMap.value[key] = tree
+        repaired = true
+      }
+    }
+    return repaired
+  }
+
   const getDict = async (dictTypes?: string[], orgId?: string): Promise<void> => {
     try {
       if (!dictTypes || !dictTypes.length) return
+      await userInfo.ensureUserHydrated()
       const tenantOrgId = resolveOrgId(orgId)
-      const dictKeySet = new Set(Object.keys(dictMap.value))
-      let uncachedDictTypes: string[] = []
-      if (orgId || tenantOrgId) {
-        const oid = orgId ?? tenantOrgId!
-        uncachedDictTypes = dictTypes.filter((dictType) => !dictKeySet.has(`${oid}:${dictType}`))
-      } else {
-        uncachedDictTypes = dictTypes.filter((dictType) => !dictKeySet.has(dictType))
+      // orgId 就绪后清理 session 里「有 key 无数据」的脏缓存，避免误判已命中
+      let cacheDirty = false
+      if (tenantOrgId) {
+        const oid = orgId ?? tenantOrgId
+        for (const key of Object.keys(dictMap.value)) {
+          if (
+            (key.startsWith(`${oid}:`) || !key.includes(':')) &&
+            Array.isArray(dictMap.value[key]) &&
+            dictMap.value[key].length === 0
+          ) {
+            delete dictMap.value[key]
+            delete dictDataMap.value[key]
+            delete dictDefaultValueMap.value[key]
+            cacheDirty = true
+          }
+        }
+      }
+      // 修复「扁平但含 parentId」的脏缓存（带 orgId 后后端未 buildTree 的历史数据）
+      if (repairCachedDictTrees()) {
+        cacheDirty = true
       }
+      if (cacheDirty) {
+        dictStores.publishToSharedCache()
+      }
+      const uncachedDictTypes = dictTypes.filter(
+        (dictType) => !hasDictCache(dictType, orgId ?? tenantOrgId),
+      )
       if (!uncachedDictTypes.length) return
       const data = await SysDictCacheApi.batchGetSysDictDataCacheVo(uncachedDictTypes, orgId ?? tenantOrgId)
-      dictMap.value = { ...dictMap.value, ...data }
-      const promises = Object.keys(data).map(async (item: string) => {
+      const normalized: typeof data = {}
+      Object.entries(data).forEach(([key, value]) => {
+        if (!value?.length) return
+        const tree = ensureDictTree(value)
+        normalized[key] = tree
+        const colon = key.indexOf(':')
+        if (colon > 0) {
+          const bare = key.slice(colon + 1)
+          if (!normalized[bare]?.length) {
+            normalized[bare] = tree
+          }
+        } else if (tenantOrgId) {
+          const scoped = `${tenantOrgId}:${key}`
+          if (!normalized[scoped]?.length) {
+            normalized[scoped] = tree
+          }
+        }
+      })
+      dictMap.value = { ...dictMap.value, ...normalized }
+      const nextDataMap = { ...dictDataMap.value }
+      const nextDefaultMap = { ...dictDefaultValueMap.value }
+      const promises = Object.keys(normalized).map(async (item: string) => {
         const dataMap: dictDataMapVoType = {}
         const defaultList: ISysDictDataCacheVo[] = []
-        await packageDictDataMap(dataMap, defaultList, data[item])
+        await packageDictDataMap(dataMap, defaultList, normalized[item])
         return { item, dataMap, defaultList }
       })
       const results = await Promise.allSettled(promises)
       results.forEach((result, index) => {
         if (result.status === 'fulfilled') {
           const { item, dataMap, defaultList } = result.value
-          dictDataMap.value[item] = dataMap
-          dictDefaultValueMap.value[item] = defaultList
+          nextDataMap[item] = dataMap
+          nextDefaultMap[item] = defaultList
         } else {
-          ElMessage.error(`处理键 ${Object.keys(data)[index]} 时出错:`, result.reason)
+          ElMessage.error(`处理键 ${Object.keys(normalized)[index]} 时出错:`, result.reason)
         }
       })
+      dictDataMap.value = nextDataMap
+      dictDefaultValueMap.value = nextDefaultMap
       dictStores.publishToSharedCache()
     } catch (error: any) {
       frameworkUtils.messageError(error)
@@ -75,13 +204,8 @@ export default function useDictHooks(dictTypes?: string[], orgId?: string) {
   }
 
   const getDictName = (value?: string, dictType?: string, orgId?: string): string | undefined => {
-    let key = orgId ? `${orgId}:${dictType}` : dictType
-    if (dictDataMap.value[key!]) return dictDataMap.value[key!][value!]?.label || value
-    const tenantOrgId = resolveOrgId()
-    if (tenantOrgId) {
-      key = `${tenantOrgId}:${dictType}`
-      if (dictDataMap.value[key!]) return dictDataMap.value[key!][value!]?.label || value
-    }
+    const key = resolveDictDataKey(dictType!, orgId)
+    if (key && dictDataMap.value[key]) return dictDataMap.value[key][value!]?.label || value
     return value
   }
 
@@ -90,52 +214,59 @@ export default function useDictHooks(dictTypes?: string[], orgId?: string) {
     dictType: string,
     orgId?: string,
   ): ISysDictDataCacheVo | {} => {
-    let key = orgId ? `${orgId}:${dictType}` : dictType
-    if (dictDataMap.value[key!] && dictDataMap.value[key!][value!])
-      return dictDataMap.value[key!][value!]
-    const tenantOrgId = resolveOrgId()
-    if (tenantOrgId) {
-      key = `${tenantOrgId}:${dictType}`
-      if (dictDataMap.value[key!] && dictDataMap.value[key!][value!])
-        return dictDataMap.value[key!][value!]
-    }
+    const key = resolveDictDataKey(dictType, orgId)
+    if (key && dictDataMap.value[key]?.[value]) return dictDataMap.value[key][value]
     return {}
   }
   const getDictDefaultValue = (
     dictType: string,
     orgId?: string
   ): ISysDictDataCacheVo[] => {
-    let key = orgId ? `${orgId}:${dictType}` : dictType
-    if (dictDefaultValueMap.value[key!]) return dictDefaultValueMap.value[key!]
     const tenantOrgId = resolveOrgId()
-    if (tenantOrgId) {
-      key = `${tenantOrgId}:${dictType}`
-      if (dictDefaultValueMap.value[key!]) return dictDefaultValueMap.value[key!]
+    const scopedOrgId = orgId ?? tenantOrgId
+    if (scopedOrgId) {
+      const scoped = dictDefaultValueMap.value[`${scopedOrgId}:${dictType}`]
+      if (scoped?.length) return scoped
     }
-    return []
+    return dictDefaultValueMap.value[dictType] ?? []
   }
   const getDictTypeData = (dictType: string, orgId?: string): ISysDictDataCacheVo[] => {
-    let key = orgId ? `${orgId}:${dictType}` : dictType
-    if (dictMap.value[key!]) return dictMap.value[key!]
-    const tenantOrgId = resolveOrgId()
-    if (tenantOrgId) {
-      key = `${tenantOrgId}:${dictType}`
-      if (dictMap.value[key!]) return dictMap.value[key!]
+    const key = resolveDictMapKey(dictType, orgId)
+    if (!key) return []
+    const list = dictMap.value[key]
+    const tree = ensureDictTree(list)
+    if (tree !== list && tree.some((item) => item.children?.length)) {
+      dictMap.value[key] = tree
+      const bare = key.includes(':') ? key.slice(key.indexOf(':') + 1) : key
+      const tenantOrgId = resolveOrgId(orgId)
+      if (tenantOrgId && !key.includes(':')) {
+        dictMap.value[`${tenantOrgId}:${bare}`] = tree
+      } else if (key.includes(':') && !dictMap.value[bare]?.some((i) => i.children?.length)) {
+        dictMap.value[bare] = tree
+      }
     }
-    return []
+    return tree
   }
   const clearDict = (dictType?: string[], orgId?: string, all?: Boolean) => {
     clearDictCache(dictType, resolveOrgId(), orgId, all)
   }
+  const userReady = ref(!dictTypes?.length)
   const dictReady = ref(!dictTypes?.length)
   if (dictTypes?.length) {
-    getDict(dictTypes, orgId).finally(() => {
+    void (async () => {
+      await userInfo.ensureUserHydrated()
+      userReady.value = true
+      await getDict(dictTypes, orgId)
       dictReady.value = true
-    })
+    })()
   }
   return {
     getDict,
+    userReady,
     dictReady,
+    dictMap,
+    dictDataMap,
+    dictDefaultValueMap,
     getDictName,
     getDictData,
     getDictTypeData,

package/src/stores/dictStore.ts

@@ -47,7 +47,7 @@ function getRootWindow(): Window {
 }
 
 function hydrateCacheFromSessionStorage(cache: SharedDictCache) {
-  const raw = sessionStorage.getItem(DICT_STORAGE_KEY)
+  const raw = getRootWindow().sessionStorage.getItem(DICT_STORAGE_KEY)
   if (!raw) return
   try {
     const parsed = JSON.parse(Base64.parse(raw).toString(Utf8)) as {
@@ -70,14 +70,15 @@ function hydrateCacheFromSessionStorage(cache: SharedDictCache) {
 }
 
 function persistCacheToSessionStorage(cache: SharedDictCache) {
-  if (typeof sessionStorage === 'undefined') return
+  if (typeof window === 'undefined') return
+  const storage = getRootWindow().sessionStorage
   try {
     const payload = JSON.stringify({
       dictMap: cache.dictMap,
       dictDataMap: cache.dictDataMap,
       dictDefaultValueMap: cache.dictDefaultValueMap,
     })
-    sessionStorage.setItem(DICT_STORAGE_KEY, Base64.stringify(Utf8.parse(payload)))
+    storage.setItem(DICT_STORAGE_KEY, Base64.stringify(Utf8.parse(payload)))
   } catch {
     // ignore quota / privacy errors
   }

package/src/stores/userInfoStore.ts

@@ -8,6 +8,12 @@ import { defineStore } from 'pinia'
 import type { IUserPermissionVo } from '../interface/IUserPermissionVo'
 import { readUserInfoFromSessionStorage } from '../utils/userSessionStorage'
 
+let hydratePromise: Promise<IUserPermissionVo | null> | null = null
+
+function resetHydratePromise() {
+  hydratePromise = null
+}
+
 export const userInfoStore = defineStore({
   id: 'userInfoStore',
   state: () => ({
@@ -16,34 +22,52 @@ export const userInfoStore = defineStore({
   }),
   getters: {
     getUserInfo(): IUserPermissionVo {
-      if (!this.user) {
-        const hydrated = readUserInfoFromSessionStorage()
-        if (hydrated) {
-          //@ts-ignore
-          this.user = hydrated
-        }
-      }
+      this.hydrateFromRootSession()
       return this.user as IUserPermissionVo
     },
   },
   actions: {
     /** 无界子应用从宿主 sessionStorage 恢复登录态（与 dictStore 同源策略） */
     hydrateFromRootSession(): IUserPermissionVo | null {
-      if (this.user) {
+      if (this.user?.orgId) {
         return this.user
       }
       const hydrated = readUserInfoFromSessionStorage()
-      if (hydrated) {
+      if (hydrated?.orgId) {
         //@ts-ignore
         this.user = hydrated
       }
       return this.user
     },
+    /** 等待宿主 sessionStorage 写入 userInfo（无界子应用首次进入菜单页） */
+    async ensureUserHydrated(maxWaitMs = 3000): Promise<IUserPermissionVo | null> {
+      if (this.user?.orgId) {
+        return this.user
+      }
+      if (!hydratePromise) {
+        hydratePromise = (async () => {
+          const deadline = Date.now() + maxWaitMs
+          while (Date.now() < deadline) {
+            const hydrated = this.hydrateFromRootSession()
+            if (hydrated?.orgId) {
+              return hydrated
+            }
+            await new Promise((resolve) => setTimeout(resolve, 50))
+          }
+          return this.user
+        })().finally(() => {
+          hydratePromise = null
+        })
+      }
+      return hydratePromise
+    },
     setUserInfo(userInfo: IUserPermissionVo) {
+      resetHydratePromise()
       //@ts-ignore
       this.user = userInfo
     },
     clear() {
+      resetHydratePromise()
       //@ts-ignore
       this.user = null
     },

package/src/utils/userSessionStorage.ts

@@ -14,8 +14,18 @@ export function getRootWindow(): Window {
 /** 从 pinia-plugin-store 持久化的 sessionStorage 恢复用户信息 */
 export function readUserInfoFromSessionStorage(storage?: Storage): IUserPermissionVo | null {
   if (typeof window === 'undefined') return null
-  const store = storage ?? getRootWindow().sessionStorage
-  const raw = store.getItem(USER_INFO_STORAGE_KEY)
+  let store: Storage
+  try {
+    store = storage ?? getRootWindow().sessionStorage
+  } catch {
+    return null
+  }
+  let raw: string | null
+  try {
+    raw = store.getItem(USER_INFO_STORAGE_KEY)
+  } catch {
+    return null
+  }
   if (!raw) return null
   try {
     const parsed = JSON.parse(Base64.parse(raw).toString(Utf8)) as {