@epxing/core 5.3.0-beta.1 → 5.3.0-beta.3

package/src/store/modules/meta.js

@@ -1,265 +1,314 @@
-/**
- * 获取页面配置
- */
-import { markRaw } from 'vue'
-import http from '@epxing/core/src/api'
-import Meta from '@epxing/core/src/runtime-utils/meta'
-import { ADD_META } from '@epxing/core/src/store/actions'
-import { prune, touch, touchKeys } from '@epxing/core/src/store/lru'
-const ADD_SIMPLE_META = 'ADD_SIMPLE_META'
-const ADD_META_RELATION_FIELDS = 'ADD_META_RELATION_FIELDS'
-const ADD_META_VIEW_FIELDS = 'ADD_META_VIEW_FIELDS'
-// 缓存容量：soft 是常态上限，hard 是极端场景兜底；正在使用的对象不会被淘汰，详见 @epxing/core/src/store/lru
-// 单个对象元数据实测约 110KB 堆（已在 @epxing/utils/src/meta 里冻结只读容器；不冻结时是 2.9MB），
-// 所以 metas 常态 50 个约 5MB、最坏 200 个约 22MB
-const LIMITS = {
-  metas: { soft: 50, hard: 200 },
-  metaRelationFields: { soft: 50, hard: 120 },
-  metaViewFields: { soft: 50, hard: 200 }
-}
-// 按条件在 metas 里查找，命中的同时记录一次使用
-const findMeta = (metas, matcher) => {
-  for (const key in metas) {
-    const item = metas[key]
-    if (item && matcher(item)) {
-      touch('metas', key)
-      return item
-    }
-  }
-  return undefined
-}
-const formatFields = (arr, flag = '') => {
-  arr.forEach(item => {
-    if (!item.field) item.field = flag ? flag.toUpperCase() + '|' + item.code : item.code
-    if (!item.codeKey) item.codeKey = item.relatedEntity
-    if (item.relationMeta) {
-      const { children, linkFlag, relationMetaList, id, text } = item.relationMeta
-      item.children = children.map(child => ({ ...child, meta: id, metaLabel: text }))
-      item.linkFlag = flag ? flag + '|' + linkFlag : linkFlag
-      if (relationMetaList) {
-        relationMetaList.forEach(meta => {
-          meta.isSub = true
-          meta.type = 'meta'
-          meta.linkFlag = item.linkFlag + '|' + meta.linkFlag
-          meta.field = meta.linkFlag
-          meta.children = meta.children.map(child => ({ ...child, meta: meta.id, metaLabel: meta.text, relationSort: meta.relationType }))
-        })
-        item.children.push(...relationMetaList)
-      }
-    }
-    if (item.children) formatFields(item.children, item.linkFlag)
-  })
-}
-
-export default {
-  state: {
-    metas: {},
-    simpleMetas: {},
-    metaStatus: {},
-    simpleMetaStatus: {},
-    metaRelationFields: {},
-    metaRelationFieldStatus: {},
-    metaViewFields: {},
-    metaViewFieldStatus: {}
-
-  },
-  mutations: {
-    [ADD_META] (state, data) {
-      touchKeys('metas', Object.keys(data))
-      state.metas = prune('metas', { ...state.metas, ...data }, LIMITS.metas)
-    },
-    [ADD_SIMPLE_META] (state, data) {
-      state.simpleMetas = { ...state.simpleMetas, ...data }
-    },
-    [ADD_META_RELATION_FIELDS] (state, data) {
-      touchKeys('metaRelationFields', Object.keys(data))
-      state.metaRelationFields = prune('metaRelationFields', { ...state.metaRelationFields, ...data }, LIMITS.metaRelationFields)
-    },
-    [ADD_META_VIEW_FIELDS] (state, data) {
-      touchKeys('metaViewFields', Object.keys(data))
-      state.metaViewFields = prune('metaViewFields', { ...state.metaViewFields, ...data }, LIMITS.metaViewFields)
-    }
-  },
-  getters: {
-    getMetaById: (state) => (id) => {
-      const meta = state.metas[id]
-      if (meta) touch('metas', id)
-      return meta
-    },
-    getMeta: (state) => (id) => {
-      return findMeta(state.metas, item => (item.id === id || item.code === id || (item.code + '@' + item.systemCode + '@' + item.clientCode) === id))
-    },
-    getSimpleMeta: (state) => (id) => {
-      return state.simpleMetas[id] || findMeta(state.metas, item => (item.id === id || item.code === id))
-    },
-    getMetaRelationFields: (state) => (id) => {
-      const fields = state.metaRelationFields[id]
-      if (fields) touch('metaRelationFields', id)
-      return fields
-    },
-    getMetaViewFields: (state) => (metaId, viewId) => {
-      const key = metaId + (viewId || '')
-      const fields = state.metaViewFields[key]
-      if (fields) touch('metaViewFields', key)
-      return fields
-    }
-  },
-  actions: {
-    [ADD_META] ({ state, commit }, payload = {}) {
-      const { [payload.metaId]: metaPromise } = state.metaStatus
-      if (metaPromise) return metaPromise
-      // eslint-disable-next-line no-async-promise-executor
-      const promise = new Promise((resolve, reject) => {
-        if (!payload.metaId) {
-          // 这条路径**不写在飞标记**（见函数末尾的 if 守卫）：原来会以 undefined 为键把这个已 reject
-          // 的 promise 存进 metaStatus，之后每次不带 metaId 的调用都命中开头的缓存判断、拿到它。
-          reject(new Error('ADD_META 缺少 metaId'))
-          return
-        }
-        http.getMeta({
-          metaId: payload.metaId.includes('@system@') ? payload.metaId.split('@')[0] : payload.metaId
-        })
-          .then(data => {
-            if (!data) {
-              // ⚠️ 这是「后端 200 但 data 为空」，**不会**走下面的 .catch —— 在 .then 里调 reject
-              // 只让外层 promise 变成 rejected，同一条链的 catch 不会被触发。
-              // 漏删在飞标记的后果不是多发一次请求，而是**本次会话再也加载不出这个对象**：
-              // action 开头的 `if (metaPromise) return metaPromise` 会一直返回这个已 reject 的
-              // promise，表现为静默失败，且**没有任何重试能恢复**，直到用户整页刷新。
-              delete state.metaStatus[payload.metaId]
-              reject(new Error(`ADD_META 后端返回空数据：metaId=${payload.metaId}`))
-              return
-            }
-            // markRaw：对象元数据(attributes/relations 大且只读、加载后不变)不做响应式，省深层 Proxy
-            // 的内存与每次字段访问的 get/set 开销；元数据从不被响应式修改(见本模块只读+LRU 删除)，安全。
-            const meta = markRaw(new Meta(data))
-            commit(ADD_META, { [payload.metaId]: meta })
-            delete state.metaStatus[payload.metaId]
-            resolve(meta)
-          })
-          .catch(err => {
-            delete state.metaStatus[payload.metaId]
-            reject(err)
-          })
-      })
-      if (payload.metaId) state.metaStatus = { ...state.metaStatus, [payload.metaId]: promise }
-      return promise
-    },
-    [ADD_SIMPLE_META] ({ state, commit }, payload = {}) {
-      const { [payload.metaId]: metaPromise } = state.simpleMetaStatus
-      if (metaPromise) return metaPromise
-      // eslint-disable-next-line no-async-promise-executor
-      const promise = new Promise((resolve, reject) => {
-        if (!payload.metaId) {
-          // 同 ADD_META：不写在飞标记，否则 undefined 键会把已 reject 的 promise 永久缓存下来。
-          reject(new Error('ADD_SIMPLE_META 缺少 metaId'))
-          return
-        }
-        http.getSimpleMeta({
-          metaId: payload.metaId
-        })
-          .then(data => {
-            if (!data) {
-              // 与 ADD_META 同一个坑：这条分支不走 .catch，漏删在飞标记会让该 metaId 本次会话永久失败。
-              delete state.simpleMetaStatus[payload.metaId]
-              reject(new Error(`ADD_SIMPLE_META 后端返回空数据：metaId=${payload.metaId}`))
-              return
-            }
-            commit(ADD_SIMPLE_META, { [payload.metaId]: markRaw(data) }) // 只读元数据，去响应式
-            delete state.simpleMetaStatus[payload.metaId]
-            // 原来这里 resolve 之后**没有 return**，成功路径也会继续走到下面的 reject(new Error())。
-            // promise 已 settle 所以状态上看不出来，但每次成功都白构造一个 Error，
-            // 更要紧的是这行让「成功」和「空数据」两条路径纠缠在一起，掩盖了上面那个漏删。
-            resolve(data)
-          })
-          .catch(err => {
-            delete state.simpleMetaStatus[payload.metaId]
-            reject(err)
-          })
-      })
-      if (payload.metaId) state.simpleMetaStatus = { ...state.simpleMetaStatus, [payload.metaId]: promise }
-      return promise
-    },
-    [ADD_META_RELATION_FIELDS] ({ state, commit }, payload = {}) {
-      const { [payload.id]: metaPromise } = state.metaRelationFieldStatus
-      if (metaPromise) return metaPromise
-      const promise = http.get({
-        action: 'metaRelationTree',
-        entityId: 'FM_ENTITY',
-        metaId: payload.id,
-        allSub: true
-      })
-        .then(data => {
-          // data 为空时原来既不删在飞标记也不 reject ⇒ 永久缓存一个 resolve 成 undefined 的 promise，
-          // 后续所有调用都直接拿到 undefined。这里只补清理、保持「resolve undefined」的既有语义
-          // （改成 reject 会波及 88 处 dispatch 的错误处理，不在本次修复范围内）。
-          if (!data) {
-            delete state.metaRelationFieldStatus[payload.id]
-            return
-          }
-          data.children = data.children.map(item => ({ ...item, meta: data.id }))
-          if (data.relationMetaList) {
-            data.relationMetaList.forEach(meta => {
-              meta.isSub = true
-              meta.type = 'meta'
-              meta.isMeta = true
-              meta.field = meta.linkFlag
-              meta.children = meta.children.map(child => ({ ...child, relationSort: meta.relationType, meta: meta.id, field: meta.linkFlag.toUpperCase() + '|' + child.code }))
-            })
-            data.children.push(...data.relationMetaList)
-          }
-          data.isMain = true
-          data.isUnFold = true
-          const fields = [data]
-          formatFields(fields)
-          commit(ADD_META_RELATION_FIELDS, { [payload.id]: markRaw(fields) }) // 只读关联字段树，去响应式
-          delete state.metaRelationFieldStatus[payload.id]
-          return fields
-        })
-        .catch(() => {
-          delete state.metaRelationFieldStatus[payload.id]
-        })
-      state.metaRelationFieldStatus = { ...state.metaRelationFieldStatus, [payload.id]: promise }
-      return promise
-    },
-    [ADD_META_VIEW_FIELDS] ({ state, commit }, payload = {}) {
-      const key = payload.metaId + (payload.viewId || '')
-      const { [key]: metaPromise } = state.metaViewFieldStatus
-      if (metaPromise) return metaPromise
-      const promise = http.get({
-        action: 'getEntityMetaView',
-        entityId: 'FM_ENTITY_VIEW',
-        metaId: payload.metaId,
-        metaViewId: payload.viewId,
-        allSub: true
-      })
-        .then(data => {
-          // 同 ADD_META_RELATION_FIELDS：补上空数据时的在飞标记清理，语义保持不变。
-          if (!data) {
-            delete state.metaViewFieldStatus[key]
-            return
-          }
-          data[0].isMain = true
-          const formatData = (arr) => {
-            return arr.filter(item => !!item).map(item => {
-              item.field = item.type === 'meta' ? item.linkFlag || item.code : item.linkCode || item.code
-              item.relationSort = item.relationType
-              if (!item.codeKey) item.codeKey = item.relatedEntity
-              if (item.type === 'meta' && item.relationType === '1') item.isSub = true
-              if (item.children) item.children = formatData(item.children)
-              return item
-            })
-          }
-          const newData = formatData(data)
-          commit(ADD_META_VIEW_FIELDS, { [key]: markRaw(newData) }) // 只读视图字段，去响应式
-          delete state.metaViewFieldStatus[key]
-          return newData
-        })
-        .catch(() => {
-          delete state.metaViewFieldStatus[key]
-        })
-      state.metaViewFieldStatus = { ...state.metaViewFieldStatus, [key]: promise }
-      return promise
-    }
-  }
-}
+/**
+ * 获取页面配置
+ */
+import { markRaw, reactive, toRaw } from 'vue'
+import http from '@epxing/core/src/api'
+import Meta from '@epxing/core/src/runtime-utils/meta'
+import { ADD_META } from '@epxing/core/src/store/actions'
+import { prune, touch, touchKeys } from '@epxing/core/src/store/lru'
+const ADD_SIMPLE_META = 'ADD_SIMPLE_META'
+const hasOwn = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key)
+// 缓存逐 key 更新，getter 从当前 store 的 state 读取，兼容独立 store 和状态替换。
+const metas = reactive({})
+// 别名 → 存储 key：同一对象可按 id / code / code@system@client 三种写法读取
+const metaAliases = new WeakMap()
+const aliasesOf = (state) => {
+  const cache = toRaw(state.metas)
+  if (!metaAliases.has(cache)) metaAliases.set(cache, {})
+  return metaAliases.get(cache)
+}
+// 每个 key 一个响应式信号，读取方只订阅自己的 key；元数据到达时只通知它
+const metaSignals = new Map()
+const signalOf = (key) => {
+  let signal = metaSignals.get(key)
+  if (!signal) {
+    signal = reactive({ version: 0 })
+    metaSignals.set(key, signal)
+  }
+  return signal
+}
+const notifyMeta = (key) => {
+  const signal = metaSignals.get(key)
+  if (signal) signal.version++
+}
+const ADD_META_RELATION_FIELDS = 'ADD_META_RELATION_FIELDS'
+const ADD_META_VIEW_FIELDS = 'ADD_META_VIEW_FIELDS'
+// 缓存容量：soft 是常态上限，hard 是极端场景兜底；正在使用的对象不会被淘汰，详见 @epxing/core/src/store/lru
+// 单个对象元数据实测约 110KB 堆（已在 @epxing/utils/src/meta 里冻结只读容器；不冻结时是 2.9MB），
+// 所以 metas 常态 50 个约 5MB、最坏 200 个约 22MB
+const LIMITS = {
+  metas: { soft: 50, hard: 200 },
+  metaRelationFields: { soft: 50, hard: 120 },
+  metaViewFields: { soft: 50, hard: 200 }
+}
+// 按条件在 metas 里查找，命中的同时记录一次使用
+const findMeta = (metas, matcher) => {
+  for (const key in metas) {
+    const item = metas[key]
+    if (item && matcher(item)) {
+      touch('metas', key)
+      return item
+    }
+  }
+  return undefined
+}
+const formatFields = (arr, flag = '') => {
+  arr.forEach(item => {
+    if (!item.field) item.field = flag ? flag.toUpperCase() + '|' + item.code : item.code
+    if (!item.codeKey) item.codeKey = item.relatedEntity
+    if (item.relationMeta) {
+      const { children, linkFlag, relationMetaList, id, text } = item.relationMeta
+      item.children = children.map(child => ({ ...child, meta: id, metaLabel: text }))
+      item.linkFlag = flag ? flag + '|' + linkFlag : linkFlag
+      if (relationMetaList) {
+        relationMetaList.forEach(meta => {
+          meta.isSub = true
+          meta.type = 'meta'
+          meta.linkFlag = item.linkFlag + '|' + meta.linkFlag
+          meta.field = meta.linkFlag
+          meta.children = meta.children.map(child => ({ ...child, meta: meta.id, metaLabel: meta.text, relationSort: meta.relationType }))
+        })
+        item.children.push(...relationMetaList)
+      }
+    }
+    if (item.children) formatFields(item.children, item.linkFlag)
+  })
+}
+
+export default {
+  state: {
+    metas,
+    simpleMetas: {},
+    metaStatus: {},
+    simpleMetaStatus: {},
+    metaRelationFields: {},
+    metaRelationFieldStatus: {},
+    metaViewFields: {},
+    metaViewFieldStatus: {}
+
+  },
+  mutations: {
+    // 逐 key 写入并只通知该 key（及其别名）的信号，不整体替换 metas
+    [ADD_META] (state, data) {
+      touchKeys('metas', Object.keys(data))
+      const metaAlias = aliasesOf(state)
+      for (const key in data) {
+        const meta = data[key]
+        state.metas[key] = meta
+        const aliases = [meta.id, meta.code, `${meta.code}@${meta.systemCode}@${meta.clientCode}`]
+        aliases.forEach(alias => {
+          if (alias && alias !== key) metaAlias[alias] = key
+        })
+        notifyMeta(key)
+        aliases.forEach(notifyMeta)
+      }
+      // 容量淘汰：先在副本上算出保留集合，再原地删除被淘汰的 key（保护期内正在用的不会被淘汰）
+      const keep = prune('metas', { ...state.metas }, LIMITS.metas)
+      for (const key in state.metas) {
+        if (!hasOwn(keep, key)) delete state.metas[key]
+      }
+    },
+    [ADD_SIMPLE_META] (state, data) {
+      state.simpleMetas = { ...state.simpleMetas, ...data }
+    },
+    [ADD_META_RELATION_FIELDS] (state, data) {
+      touchKeys('metaRelationFields', Object.keys(data))
+      state.metaRelationFields = prune('metaRelationFields', { ...state.metaRelationFields, ...data }, LIMITS.metaRelationFields)
+    },
+    [ADD_META_VIEW_FIELDS] (state, data) {
+      touchKeys('metaViewFields', Object.keys(data))
+      state.metaViewFields = prune('metaViewFields', { ...state.metaViewFields, ...data }, LIMITS.metaViewFields)
+    }
+  },
+  getters: {
+    getMetaById: (state) => (id) => {
+      // eslint-disable-next-line no-unused-expressions
+      signalOf(id).version
+      const meta = state.metas[id]
+      if (meta) touch('metas', id)
+      return meta
+    },
+    getMeta: (state) => (id) => {
+      if (!id) return undefined
+      // 只订阅这一个 key 的信号，其它元数据的到达不会触发本组件重渲染
+      // eslint-disable-next-line no-unused-expressions
+      signalOf(id).version
+      const key = hasOwn(state.metas, id) ? id : aliasesOf(state)[id]
+      const meta = key ? state.metas[key] : undefined
+      if (meta) touch('metas', key)
+      return meta
+    },
+    getSimpleMeta: (state) => (id) => {
+      return state.simpleMetas[id] || findMeta(state.metas, item => (item.id === id || item.code === id))
+    },
+    getMetaRelationFields: (state) => (id) => {
+      const fields = state.metaRelationFields[id]
+      if (fields) touch('metaRelationFields', id)
+      return fields
+    },
+    getMetaViewFields: (state) => (metaId, viewId) => {
+      const key = metaId + (viewId || '')
+      const fields = state.metaViewFields[key]
+      if (fields) touch('metaViewFields', key)
+      return fields
+    }
+  },
+  actions: {
+    [ADD_META] ({ state, commit }, payload = {}) {
+      const { [payload.metaId]: metaPromise } = state.metaStatus
+      if (metaPromise) return metaPromise
+      // eslint-disable-next-line no-async-promise-executor
+      const promise = new Promise((resolve, reject) => {
+        if (!payload.metaId) {
+          // 这条路径**不写在飞标记**（见函数末尾的 if 守卫）：原来会以 undefined 为键把这个已 reject
+          // 的 promise 存进 metaStatus，之后每次不带 metaId 的调用都命中开头的缓存判断、拿到它。
+          reject(new Error('ADD_META 缺少 metaId'))
+          return
+        }
+        http.getMeta({
+          metaId: payload.metaId.includes('@system@') ? payload.metaId.split('@')[0] : payload.metaId
+        })
+          .then(data => {
+            if (!data) {
+              // ⚠️ 这是「后端 200 但 data 为空」，**不会**走下面的 .catch —— 在 .then 里调 reject
+              // 只让外层 promise 变成 rejected，同一条链的 catch 不会被触发。
+              // 漏删在飞标记的后果不是多发一次请求，而是**本次会话再也加载不出这个对象**：
+              // action 开头的 `if (metaPromise) return metaPromise` 会一直返回这个已 reject 的
+              // promise，表现为静默失败，且**没有任何重试能恢复**，直到用户整页刷新。
+              delete state.metaStatus[payload.metaId]
+              reject(new Error(`ADD_META 后端返回空数据：metaId=${payload.metaId}`))
+              return
+            }
+            // markRaw：对象元数据(attributes/relations 大且只读、加载后不变)不做响应式，省深层 Proxy
+            // 的内存与每次字段访问的 get/set 开销；元数据从不被响应式修改(见本模块只读+LRU 删除)，安全。
+            const meta = markRaw(new Meta(data))
+            commit(ADD_META, { [payload.metaId]: meta })
+            delete state.metaStatus[payload.metaId]
+            resolve(meta)
+          })
+          .catch(err => {
+            delete state.metaStatus[payload.metaId]
+            reject(err)
+          })
+      })
+      if (payload.metaId) state.metaStatus = { ...state.metaStatus, [payload.metaId]: promise }
+      return promise
+    },
+    [ADD_SIMPLE_META] ({ state, commit }, payload = {}) {
+      const { [payload.metaId]: metaPromise } = state.simpleMetaStatus
+      if (metaPromise) return metaPromise
+      // eslint-disable-next-line no-async-promise-executor
+      const promise = new Promise((resolve, reject) => {
+        if (!payload.metaId) {
+          // 同 ADD_META：不写在飞标记，否则 undefined 键会把已 reject 的 promise 永久缓存下来。
+          reject(new Error('ADD_SIMPLE_META 缺少 metaId'))
+          return
+        }
+        http.getSimpleMeta({
+          metaId: payload.metaId
+        })
+          .then(data => {
+            if (!data) {
+              // 与 ADD_META 同一个坑：这条分支不走 .catch，漏删在飞标记会让该 metaId 本次会话永久失败。
+              delete state.simpleMetaStatus[payload.metaId]
+              reject(new Error(`ADD_SIMPLE_META 后端返回空数据：metaId=${payload.metaId}`))
+              return
+            }
+            commit(ADD_SIMPLE_META, { [payload.metaId]: markRaw(data) }) // 只读元数据，去响应式
+            delete state.simpleMetaStatus[payload.metaId]
+            // 原来这里 resolve 之后**没有 return**，成功路径也会继续走到下面的 reject(new Error())。
+            // promise 已 settle 所以状态上看不出来，但每次成功都白构造一个 Error，
+            // 更要紧的是这行让「成功」和「空数据」两条路径纠缠在一起，掩盖了上面那个漏删。
+            resolve(data)
+          })
+          .catch(err => {
+            delete state.simpleMetaStatus[payload.metaId]
+            reject(err)
+          })
+      })
+      if (payload.metaId) state.simpleMetaStatus = { ...state.simpleMetaStatus, [payload.metaId]: promise }
+      return promise
+    },
+    [ADD_META_RELATION_FIELDS] ({ state, commit }, payload = {}) {
+      const { [payload.id]: metaPromise } = state.metaRelationFieldStatus
+      if (metaPromise) return metaPromise
+      const promise = http.get({
+        action: 'metaRelationTree',
+        entityId: 'FM_ENTITY',
+        metaId: payload.id,
+        allSub: true
+      })
+        .then(data => {
+          // data 为空时原来既不删在飞标记也不 reject ⇒ 永久缓存一个 resolve 成 undefined 的 promise，
+          // 后续所有调用都直接拿到 undefined。这里只补清理、保持「resolve undefined」的既有语义
+          // （改成 reject 会波及 88 处 dispatch 的错误处理，不在本次修复范围内）。
+          if (!data) {
+            delete state.metaRelationFieldStatus[payload.id]
+            return
+          }
+          data.children = data.children.map(item => ({ ...item, meta: data.id }))
+          if (data.relationMetaList) {
+            data.relationMetaList.forEach(meta => {
+              meta.isSub = true
+              meta.type = 'meta'
+              meta.isMeta = true
+              meta.field = meta.linkFlag
+              meta.children = meta.children.map(child => ({ ...child, relationSort: meta.relationType, meta: meta.id, field: meta.linkFlag.toUpperCase() + '|' + child.code }))
+            })
+            data.children.push(...data.relationMetaList)
+          }
+          data.isMain = true
+          data.isUnFold = true
+          const fields = [data]
+          formatFields(fields)
+          commit(ADD_META_RELATION_FIELDS, { [payload.id]: markRaw(fields) }) // 只读关联字段树，去响应式
+          delete state.metaRelationFieldStatus[payload.id]
+          return fields
+        })
+        .catch(() => {
+          delete state.metaRelationFieldStatus[payload.id]
+        })
+      state.metaRelationFieldStatus = { ...state.metaRelationFieldStatus, [payload.id]: promise }
+      return promise
+    },
+    [ADD_META_VIEW_FIELDS] ({ state, commit }, payload = {}) {
+      const key = payload.metaId + (payload.viewId || '')
+      const { [key]: metaPromise } = state.metaViewFieldStatus
+      if (metaPromise) return metaPromise
+      const promise = http.get({
+        action: 'getEntityMetaView',
+        entityId: 'FM_ENTITY_VIEW',
+        metaId: payload.metaId,
+        metaViewId: payload.viewId,
+        allSub: true
+      })
+        .then(data => {
+          // 同 ADD_META_RELATION_FIELDS：补上空数据时的在飞标记清理，语义保持不变。
+          if (!data) {
+            delete state.metaViewFieldStatus[key]
+            return
+          }
+          data[0].isMain = true
+          const formatData = (arr) => {
+            return arr.filter(item => !!item).map(item => {
+              item.field = item.type === 'meta' ? item.linkFlag || item.code : item.linkCode || item.code
+              item.relationSort = item.relationType
+              if (!item.codeKey) item.codeKey = item.relatedEntity
+              if (item.type === 'meta' && item.relationType === '1') item.isSub = true
+              if (item.children) item.children = formatData(item.children)
+              return item
+            })
+          }
+          const newData = formatData(data)
+          commit(ADD_META_VIEW_FIELDS, { [key]: markRaw(newData) }) // 只读视图字段，去响应式
+          delete state.metaViewFieldStatus[key]
+          return newData
+        })
+        .catch(() => {
+          delete state.metaViewFieldStatus[key]
+        })
+      state.metaViewFieldStatus = { ...state.metaViewFieldStatus, [key]: promise }
+      return promise
+    }
+  }
+}

package/src/style-presets.js

@@ -62,14 +62,14 @@ export const STYLE_AXES = [
 ]
 
 // 应用一套预设：把四个轴值写进 uiSettings（触发 applyTheme + 差量落盘）
-export function applyStylePreset (presetKey) {
+export function applyStylePreset (presetKey, settings = uiSettings) {
   const preset = STYLE_PRESETS.find(p => p.key === presetKey)
   if (!preset) return
-  Object.keys(AXIS_ATTRS).forEach(k => { uiSettings[k] = preset[k] })
+  Object.keys(AXIS_ATTRS).forEach(k => { settings[k] = preset[k] })
 }
 
 // 当前轴值组合命中哪套预设（设置面板高亮用）；都不命中返回 ''（= 用户自定义了组合）
-export function matchStylePreset () {
+export function matchStylePreset (settings = uiSettings) {
   // 先把四个轴全读进 cur 再比，而不是在 every() 回调里现读：every()/find() 都会短路，现读的话
   // 「第一个不匹配的轴」之后的轴根本不会被读到，也就不会被 Vue 登记为响应式依赖——依赖集完不完整
   // 变成了「预设表长什么样」的函数。
@@ -80,7 +80,7 @@ export function matchStylePreset () {
   // 这里改成先全读，是把「依赖完整」从一条依赖预设表形状的隐性推理，变成无条件成立的事实——
   // 于是调用方（AppSettings 的 currentPreset）可以直接 return，不必再挂一个「依赖预读」数组兜底。
   const cur = {}
-  for (const k of Object.keys(AXIS_ATTRS)) cur[k] = uiSettings[k]
+  for (const k of Object.keys(AXIS_ATTRS)) cur[k] = settings[k]
   const hit = STYLE_PRESETS.find(p => Object.keys(AXIS_ATTRS).every(k => cur[k] === p[k]))
   return hit ? hit.key : ''
 }