adtec-core-package 3.0.5 → 3.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adtec-core-package",
-  "version": "3.0.5",
+  "version": "3.0.8",
   "private": false,
   "type": "module",
   "exports": {

package/src/hooks/useDictHooks.ts

@@ -1,4 +1,5 @@
 import { ElMessage } from 'element-plus'
+import { ref } from 'vue'
 import SysDictCacheApi from '../api/SysDictCacheApi'
 import type { ISysDictDataCacheVo } from '../interface/ISysDictDataCacheVo'
 import { type dictDataMapVoType, dictStore } from '../stores/dictStore'
@@ -46,6 +47,7 @@ export default function useDictHooks(dictTypes?: string[], orgId?: string) {
           ElMessage.error(`处理键 ${Object.keys(data)[index]} 时出错:`, result.reason)
         }
       })
+      dictStores.publishToSharedCache()
     } catch (error: any) {
       frameworkUtils.messageError(error)
     }
@@ -114,10 +116,16 @@ export default function useDictHooks(dictTypes?: string[], orgId?: string) {
   const clearDict = (dictType?: string[], orgId?: string, all?: Boolean) => {
     clearDictCache(dictType, userInfo.getUserInfo.orgId, orgId, all)
   }
-  getDict(dictTypes, orgId).then(() => {
-  })
+  /** 构造函数传入的 dictTypes 是否已全部加载（缓存命中也会立即置 true） */
+  const dictReady = ref(!dictTypes?.length)
+  if (dictTypes?.length) {
+    getDict(dictTypes, orgId).finally(() => {
+      dictReady.value = true
+    })
+  }
   return {
     getDict,
+    dictReady,
     getDictName,
     getDictData,
     getDictTypeData,

package/src/stores/dictStore.ts

@@ -18,27 +18,35 @@ export interface dictDataMapType {
 }
 
 const DICT_STORAGE_KEY = 'dictStore'
+const DICT_CACHE_UPDATE_EVENT = 'adtec-dict-cache-update'
 
-export interface SharedDictState {
-  dictMap: Ref<dictMapType>
-  dictDataMap: Ref<dictDataMapType>
-  dictDefaultValueMap: Ref<dictMapType>
+/** 跨应用共享的 plain 缓存（非 Vue ref，避免 wujie 子应用与宿主 ref 响应式隔离） */
+export interface SharedDictCache {
+  dictMap: dictMapType
+  dictDataMap: dictDataMapType
+  dictDefaultValueMap: dictMapType
 }
 
 declare global {
   interface Window {
-    __ADTEC_SHARED_DICT__?: SharedDictState
+    __ADTEC_SHARED_DICT_CACHE__?: SharedDictCache
+    /** @deprecated 3.0.7 起改用 __ADTEC_SHARED_DICT_CACHE__ */
+    __ADTEC_SHARED_DICT__?: {
+      dictMap: Ref<dictMapType>
+      dictDataMap: Ref<dictDataMapType>
+      dictDefaultValueMap: Ref<dictMapType>
+    }
   }
 }
 
-/** wujie 子应用走 parent，宿主/独立 dev 走自身 window —— 全应用共享同一份 ref */
+/** wujie 子应用走 parent，宿主/独立 dev 走自身 window */
 function getRootWindow(): Window {
   if (typeof window === 'undefined') return window
   const w = window as Window & { __POWERED_BY_WUJIE__?: boolean }
   return w.__POWERED_BY_WUJIE__ ? window.parent : window
 }
 
-function hydrateFromSessionStorage(state: SharedDictState) {
+function hydrateCacheFromSessionStorage(cache: SharedDictCache) {
   const raw = sessionStorage.getItem(DICT_STORAGE_KEY)
   if (!raw) return
   try {
@@ -48,45 +56,129 @@ function hydrateFromSessionStorage(state: SharedDictState) {
       dictDefaultValueMap?: dictMapType
     }
     if (parsed.dictMap) {
-      state.dictMap.value = { ...parsed.dictMap, ...state.dictMap.value }
+      Object.assign(cache.dictMap, parsed.dictMap)
     }
     if (parsed.dictDataMap) {
-      state.dictDataMap.value = { ...parsed.dictDataMap, ...state.dictDataMap.value }
+      mergeDictDataMap(cache.dictDataMap, parsed.dictDataMap)
     }
     if (parsed.dictDefaultValueMap) {
-      state.dictDefaultValueMap.value = {
-        ...parsed.dictDefaultValueMap,
-        ...state.dictDefaultValueMap.value,
-      }
+      Object.assign(cache.dictDefaultValueMap, parsed.dictDefaultValueMap)
     }
   } catch {
     // ignore corrupt session data
   }
 }
 
-/** 宿主 window 单例：alive 子应用与宿主读写同一组 Vue ref（刷新时仍由 sessionStorage 恢复） */
-export function getSharedDictRefs(): SharedDictState {
+function persistCacheToSessionStorage(cache: SharedDictCache) {
+  if (typeof sessionStorage === 'undefined') return
+  try {
+    const payload = JSON.stringify({
+      dictMap: cache.dictMap,
+      dictDataMap: cache.dictDataMap,
+      dictDefaultValueMap: cache.dictDefaultValueMap,
+    })
+    sessionStorage.setItem(DICT_STORAGE_KEY, Base64.stringify(Utf8.parse(payload)))
+  } catch {
+    // ignore quota / privacy errors
+  }
+}
+
+function mergeDictDataMap(target: dictDataMapType, source: dictDataMapType) {
+  Object.keys(source).forEach((key) => {
+    target[key] = { ...target[key], ...source[key] }
+  })
+}
+
+function cloneDictDataMap(source: dictDataMapType): dictDataMapType {
+  const clone: dictDataMapType = {}
+  mergeDictDataMap(clone, source)
+  return clone
+}
+
+/** 宿主 window 单例 plain 缓存：alive 子应用与宿主共享数据，但不共享 Vue ref */
+export function getSharedDictCache(): SharedDictCache {
+  const root = getRootWindow()
+  if (!root.__ADTEC_SHARED_DICT_CACHE__) {
+    root.__ADTEC_SHARED_DICT_CACHE__ = {
+      dictMap: {},
+      dictDataMap: {},
+      dictDefaultValueMap: {},
+    }
+    hydrateCacheFromSessionStorage(root.__ADTEC_SHARED_DICT_CACHE__)
+  }
+  return root.__ADTEC_SHARED_DICT_CACHE__
+}
+
+function broadcastDictCacheUpdate() {
+  if (typeof window === 'undefined') return
+  const event = new CustomEvent(DICT_CACHE_UPDATE_EVENT)
+  window.dispatchEvent(event)
   const root = getRootWindow()
-  if (!root.__ADTEC_SHARED_DICT__) {
-    root.__ADTEC_SHARED_DICT__ = {
-      dictMap: ref<dictMapType>({}),
-      dictDataMap: ref<dictDataMapType>({}),
-      dictDefaultValueMap: ref<dictMapType>({}),
+  if (root !== window) {
+    try {
+      root.dispatchEvent(new CustomEvent(DICT_CACHE_UPDATE_EVENT))
+    } catch {
+      // cross-origin parent
     }
-    hydrateFromSessionStorage(root.__ADTEC_SHARED_DICT__)
   }
-  return root.__ADTEC_SHARED_DICT__
 }
 
-/** @deprecated 已由 getSharedDictRefs 在初始化时 hydrate；保留兼容旧调用 */
-export function syncDictFromSessionStorage(target: SharedDictState) {
-  hydrateFromSessionStorage(target)
+/** @deprecated 3.0.7 起请使用 getSharedDictCache */
+export function getSharedDictRefs() {
+  return getSharedDictCache() as unknown as {
+    dictMap: Ref<dictMapType>
+    dictDataMap: Ref<dictDataMapType>
+    dictDefaultValueMap: Ref<dictMapType>
+  }
+}
+
+/** @deprecated 已由 getSharedDictCache 在初始化时 hydrate */
+export function syncDictFromSessionStorage(_target?: unknown) {
+  hydrateCacheFromSessionStorage(getSharedDictCache())
 }
 
 export const dictStore = defineStore('dictStore', () => {
-  const { dictMap, dictDataMap, dictDefaultValueMap } = getSharedDictRefs()
+  const sharedCache = getSharedDictCache()
 
-  const clearDictCache = (dictType?: string[], userOrgId?: string, orgId?: string, all?: Boolean) => {
+  /** 当前应用 Pinia 内的 ref，保证与本应用 Vue 响应式连通 */
+  const dictMap = ref<dictMapType>({ ...sharedCache.dictMap })
+  const dictDataMap = ref<dictDataMapType>(cloneDictDataMap(sharedCache.dictDataMap))
+  const dictDefaultValueMap = ref<dictMapType>({ ...sharedCache.dictDefaultValueMap })
+
+  const syncFromSharedCache = () => {
+    dictMap.value = { ...dictMap.value, ...sharedCache.dictMap }
+    mergeDictDataMap(dictDataMap.value, sharedCache.dictDataMap)
+    dictDefaultValueMap.value = { ...dictDefaultValueMap.value, ...sharedCache.dictDefaultValueMap }
+  }
+
+  const publishToSharedCache = () => {
+    Object.assign(sharedCache.dictMap, dictMap.value)
+    mergeDictDataMap(sharedCache.dictDataMap, dictDataMap.value)
+    Object.assign(sharedCache.dictDefaultValueMap, dictDefaultValueMap.value)
+    persistCacheToSessionStorage(sharedCache)
+    broadcastDictCacheUpdate()
+  }
+
+  if (typeof window !== 'undefined') {
+    window.addEventListener(DICT_CACHE_UPDATE_EVENT, syncFromSharedCache)
+    const root = getRootWindow()
+    if (root !== window) {
+      try {
+        root.addEventListener(DICT_CACHE_UPDATE_EVENT, syncFromSharedCache)
+      } catch {
+        // cross-origin parent
+      }
+    }
+  }
+
+  syncFromSharedCache()
+
+  const clearDictCache = (
+    dictType?: string[],
+    userOrgId?: string,
+    orgId?: string,
+    all?: Boolean,
+  ) => {
     if (dictType && dictType.length > 0) {
       dictType.forEach((item) => {
         if (orgId) {
@@ -94,6 +186,9 @@ export const dictStore = defineStore('dictStore', () => {
           delete dictMap.value[key]
           delete dictDataMap.value[key]
           delete dictDefaultValueMap.value[key]
+          delete sharedCache.dictMap[key]
+          delete sharedCache.dictDataMap[key]
+          delete sharedCache.dictDefaultValueMap[key]
         } else {
           delete dictMap.value[item]
           delete dictDataMap.value[item]
@@ -101,18 +196,32 @@ export const dictStore = defineStore('dictStore', () => {
           delete dictMap.value[`${userOrgId}:${item}`]
           delete dictDataMap.value[`${userOrgId}:${item}`]
           delete dictDefaultValueMap.value[`${userOrgId}:${item}`]
+          delete sharedCache.dictMap[item]
+          delete sharedCache.dictDataMap[item]
+          delete sharedCache.dictDefaultValueMap[item]
+          delete sharedCache.dictMap[`${userOrgId}:${item}`]
+          delete sharedCache.dictDataMap[`${userOrgId}:${item}`]
+          delete sharedCache.dictDefaultValueMap[`${userOrgId}:${item}`]
         }
       })
+      publishToSharedCache()
     } else if (all) {
       dictMap.value = {}
       dictDataMap.value = {}
       dictDefaultValueMap.value = {}
+      sharedCache.dictMap = {}
+      sharedCache.dictDataMap = {}
+      sharedCache.dictDefaultValueMap = {}
+      publishToSharedCache()
     }
   }
+
   return {
     dictMap,
     dictDataMap,
     dictDefaultValueMap,
     clearDictCache,
+    syncFromSharedCache,
+    publishToSharedCache,
   }
 })

package/src/utils/applyObjectHasOwnPolyfill.ts

@@ -0,0 +1,14 @@
+type ObjectWithHasOwn = typeof Object & {
+  hasOwn?: (object: object, property: PropertyKey) => boolean
+}
+
+/** 旧浏览器 / 部分 WebView 无 Object.hasOwn，需在业务 bundle 之前注入 */
+export function applyObjectHasOwnPolyfill(target: typeof globalThis = globalThis) {
+  const objectCtor = target.Object as ObjectWithHasOwn
+  if (typeof objectCtor.hasOwn === 'function') {
+    return
+  }
+  objectCtor.hasOwn = function (object, property) {
+    return objectCtor.prototype.hasOwnProperty.call(object, property)
+  }
+}