adtec-core-package 3.0.4 → 3.0.7

package/src/components/editor-main/src/utils/editor-scroll.js

@@ -1,35 +1,59 @@
+/** TipTap focus 选项：不触发 ProseMirror scrollIntoView */
+export const FOCUS_WITHOUT_SCROLL = { scrollIntoView: false }
+
+function pushScrollPosition(positions, seen, el) {
+  if (!el || seen.has(el)) return
+  seen.add(el)
+  positions.push({
+    el,
+    top: el.scrollTop,
+    left: el.scrollLeft,
+  })
+}
+
 /**
- * 保存/恢复编辑器及外层滚动位置，避免 setBlockType 等命令触发 scrollIntoView 导致页面跳动。
+ * 保存/恢复编辑器及外层滚动位置，避免 toolbar focus / setBlockType 等触发 scrollIntoView 导致页面跳动。
  */
 export function captureScrollPositions(container) {
   const positions = []
+  const seen = new Set()
   const pageContainer = document.querySelector(
     `${container} .umo-zoomable-container`,
   )
-  if (pageContainer) {
-    positions.push({
-      el: pageContainer,
-      top: pageContainer.scrollTop,
-      left: pageContainer.scrollLeft,
-    })
-  }
+  pushScrollPosition(positions, seen, pageContainer)
 
-  let node = pageContainer?.parentElement ?? null
+  let node =
+    pageContainer?.parentElement ??
+    document.querySelector(container)?.parentElement ??
+    null
   while (node && node !== document.documentElement) {
     if (node.classList?.contains('el-scrollbar__wrap')) {
-      positions.push({
-        el: node,
-        top: node.scrollTop,
-        left: node.scrollLeft,
-      })
-      break
+      pushScrollPosition(positions, seen, node)
+    } else {
+      const style = getComputedStyle(node)
+      const overflow = `${style.overflow}${style.overflowY}${style.overflowX}`
+      if (/auto|scroll/.test(overflow)) {
+        pushScrollPosition(positions, seen, node)
+      }
     }
     node = node.parentElement
   }
 
+  pushScrollPosition(positions, seen, document.documentElement)
+  pushScrollPosition(positions, seen, document.body)
+
   return positions
 }
 
+export function runPreservingScroll(container, fn) {
+  const scrollPositions = captureScrollPositions(container)
+  try {
+    return fn()
+  } finally {
+    restoreScrollPositions(scrollPositions)
+  }
+}
+
 export function restoreScrollPositions(positions) {
   if (!positions.length) return
   const apply = () => {

package/src/components/vxeGrid/index.vue

@@ -7,14 +7,15 @@
 <script setup lang="ts">
 //@ts-ignore
 import { components, initVxeTableInPage } from 'adtec-core-package/src/config/VxeTableConfig'
-// 导入默认的语言
 import { defineComponent, getCurrentInstance, h } from 'vue'
+
 const { VxeGrid } = components
 defineComponent({
   components: {
     VxeGrid,
   },
 })
+
 const { renderComponent = { enableElementPlus: true, enableExcel: false, enablePdf: false } } =
   defineProps<{
     renderComponent?: {
@@ -24,12 +25,18 @@ const { renderComponent = { enableElementPlus: true, enableExcel: false, enableP
     }
   }>()
 
-initVxeTableInPage(renderComponent.enableExcel,renderComponent.enablePdf)
+initVxeTableInPage(
+  renderComponent.enableExcel,
+  renderComponent.enablePdf,
+  renderComponent.enableElementPlus ?? true,
+)
 
 const vm = getCurrentInstance()
 
-const changeRef = (exposed: any) => {
-  vm && (vm.exposed = exposed)
+const changeRef = (exposed: unknown) => {
+  if (vm) {
+    vm.exposed = exposed
+  }
 }
 </script>
 

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

@@ -1,6 +1,9 @@
 import { defineStore } from 'pinia'
-import { ref } from 'vue'
+import { ref, type Ref } from 'vue'
+import Base64 from 'crypto-js/enc-base64'
+import Utf8 from 'crypto-js/enc-utf8'
 import type { ISysDictDataCacheVo } from '../interface/ISysDictDataCacheVo'
+
 // 定义包含map的整体类型
 export interface dictMapType {
   [key: string]: ISysDictDataCacheVo[]
@@ -14,12 +17,168 @@ export interface dictDataMapType {
   [key: string]: { [key: string]: ISysDictDataCacheVo }
 }
 
+const DICT_STORAGE_KEY = 'dictStore'
+const DICT_CACHE_UPDATE_EVENT = 'adtec-dict-cache-update'
+
+/** 跨应用共享的 plain 缓存（非 Vue ref，避免 wujie 子应用与宿主 ref 响应式隔离） */
+export interface SharedDictCache {
+  dictMap: dictMapType
+  dictDataMap: dictDataMapType
+  dictDefaultValueMap: dictMapType
+}
+
+declare global {
+  interface Window {
+    __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 */
+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 hydrateCacheFromSessionStorage(cache: SharedDictCache) {
+  const raw = sessionStorage.getItem(DICT_STORAGE_KEY)
+  if (!raw) return
+  try {
+    const parsed = JSON.parse(Base64.parse(raw).toString(Utf8)) as {
+      dictMap?: dictMapType
+      dictDataMap?: dictDataMapType
+      dictDefaultValueMap?: dictMapType
+    }
+    if (parsed.dictMap) {
+      Object.assign(cache.dictMap, parsed.dictMap)
+    }
+    if (parsed.dictDataMap) {
+      mergeDictDataMap(cache.dictDataMap, parsed.dictDataMap)
+    }
+    if (parsed.dictDefaultValueMap) {
+      Object.assign(cache.dictDefaultValueMap, parsed.dictDefaultValueMap)
+    }
+  } catch {
+    // ignore corrupt session data
+  }
+}
+
+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 !== window) {
+    try {
+      root.dispatchEvent(new CustomEvent(DICT_CACHE_UPDATE_EVENT))
+    } catch {
+      // cross-origin parent
+    }
+  }
+}
+
+/** @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 = ref<dictMapType>({})
-  const dictDataMap = ref<dictDataMapType>({})
-  const dictDefaultValueMap = ref<dictMapType>({})
+  const sharedCache = getSharedDictCache()
+
+  /** 当前应用 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()
+  }
 
-  const clearDictCache = (dictType?: string[],userOrgId?: string, orgId?: string, all?: Boolean) => {
+  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) {
@@ -27,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]
@@ -34,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,
   }
 })