n20-common-lib 3.2.40 → 3.2.43

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "n20-common-lib",
-  "version": "3.2.40",
+  "version": "3.2.43",
   "private": false,
   "scripts": {
-    "serve": "vue-cli-service serve",
+    "serve": "pnpm --dir ../packages/docs run serve",
     "prepublishOnly": "npm run build:css",
     "build": "node versionInfo.js && npm run build:css && vue-cli-service build --testTheme",
     "test:unit": "vue-cli-service test:unit",
@@ -68,6 +68,7 @@
     "v-viewer": "1.6.4",
     "vue-jsonp": "2.0.0",
     "vuedraggable": "*",
+    "worker-loader": "^3.0.8",
     "webpack-duplicate-relano-plugin": "^0.1.0",
     "xe-utils": "4.0.2"
   },

package/src/components/DatePicker/index.vue

@@ -22,6 +22,8 @@
 </template>
 
 <script>
+import { $lc } from '../../utils/i18n/index'
+
 const LONG_TERM_DATE = new Date(9999, 11, 31, 23, 59, 59)
 
 export default {
@@ -45,7 +47,7 @@ export default {
     },
     longTermLabel: {
       type: String,
-      default: $lc("长期")
+      default: $lc('长期')
     }
   },
   computed: {

package/src/components/FileUploadTable/index.vue

@@ -268,7 +268,13 @@
       :close-on-click-modal="false"
       :destroy-on-open="true"
     >
-      <el-select v-model="bathType" class="m-b-s w-100p" clearable @change="handleBathChange">
+      <el-select
+        v-if="!autoMatchBatchFileType"
+        v-model="bathType"
+        class="m-b-s w-100p"
+        clearable
+        @change="handleBathChange"
+      >
         <el-option
           v-for="item in typeOptions"
           :key="item.type"
@@ -278,7 +284,7 @@
         />
       </el-select>
       <Upload
-        v-if="bathType"
+        v-if="autoMatchBatchFileType || bathType"
         ref="upload-batch"
         class="n20-upload-drag"
         :msg-type="null"
@@ -305,7 +311,7 @@
         </template>
       </Upload>
       <div class="dialog-footer">
-        <el-button type="primary" @click="batchUploadFn">{{ '确认' | $lc }}</el-button>
+        <el-button type="primary" :loading="batchUploading" @click="batchUploadFn">{{ '确认' | $lc }}</el-button>
         <el-button plain @click="visibleBatch = false">{{ '取消' | $lc }}</el-button>
       </div>
     </Dialog>
@@ -434,6 +440,10 @@ export default {
       type: Boolean,
       default: false
     },
+    autoMatchBatchFileType: {
+      type: Boolean,
+      default: false
+    },
     showBatchPrint: {
       type: Boolean,
       default: false
@@ -498,6 +508,7 @@ export default {
       previewSameOrg: false,
       seeRow: {},
       officeStatus: false,
+      batchUploading: false,
       // 批量上传使用的文件数据（避免直接修改计算属性）
       _batchFileData: null
     }
@@ -752,11 +763,91 @@ export default {
         data: JSON.stringify(dto)
       }
     },
-    batchUploadFn() {
+    async batchUploadFn() {
+      if (this.autoMatchBatchFileType) {
+        await this.autoMatchBatchUpload()
+        return
+      }
       let $uploadwrap = this.$refs['upload-batch']
       // 直接提交上传，关闭对话框的逻辑在 batchSuccess 回调中处理
       $uploadwrap.submit()
     },
+    async autoMatchBatchUpload() {
+      let $uploadwrap = this.$refs['upload-batch']
+      let uploadFiles = $uploadwrap?.$refs?.upload?.uploadFiles || []
+      let files = uploadFiles.filter((item) => item.status === 'ready' && item.raw)
+      if (!files.length) {
+        this.$message.warning($lc('请先选择上传文件'))
+        return
+      }
+
+      try {
+        for (let item of files) {
+          let result = await $uploadwrap.beforeUploadFn(item.raw)
+          if (result === false) {
+            return
+          }
+        }
+
+        let FD = new FormData()
+        files.forEach((item) => {
+          FD.append('file', item.raw)
+        })
+
+        let remoteFileUpload = JSON.parse(this.fileData?.data || '{}')
+        remoteFileUpload.bussValues = this.typeOptions.map((item) => item.type)
+        FD.append('remoteFileUpload', JSON.stringify(remoteFileUpload))
+
+        this.batchUploading = true
+        let { data } = await axios.post(
+          this.apiPrefix
+            ? `${this.apiPrefix}/neams/eamsbaserecord/batchSaveFile`
+            : '/neams/eamsbaserecord/batchSaveFile',
+          FD,
+          {
+            headers: Object.assign(auth.setHeaders(this.headers), { 'Content-Type': 'multipart/form-data' }),
+            loading: false,
+            noMsg: true,
+            timeout: 900000
+          }
+        )
+
+        let responseList = Array.isArray(data) ? data : []
+        let rows = responseList.map((item) => this.buildAutoMatchBatchRow(item))
+        this.tableData.splice(0, 0, ...rows)
+        let pendingFiles = [...files]
+        rows.forEach((row) => {
+          let fileIndex = pendingFiles.findIndex((item) => item.raw.name === row[this.keys.name])
+          let sourceFile = pendingFiles.splice(fileIndex > -1 ? fileIndex : 0, 1)[0]
+          this.$emit('on-success', sourceFile?.raw, row)
+        })
+
+        $uploadwrap.clearFiles()
+        $uploadwrap.fileList = []
+        this.visibleBatch = false
+      } catch (err) {
+        this.$message.error(err?.msg || $lc('上传失败'))
+      } finally {
+        this.batchUploading = false
+      }
+    },
+    buildAutoMatchBatchRow(item) {
+      let userInfo = JSON.parse(sessionStorage.getItem('userInfo') || '{}')
+      let row = {
+        ...item,
+        _name: item.fileName,
+        _percent: 100,
+        _status: 'success',
+        _typeDisabled: false
+      }
+      row[this.keys.rowKey] = item.beid
+      row[this.keys.type] = item.attno
+      row[this.keys.name] = item.fileName
+      row[this.keys.url] = this.keys.url === this.keys.rowKey ? item.beid : item.filePath || item.beid
+      row[this.keys.time] = row[this.keys.time] || dayjs().format('YYYY-MM-DD HH:mm:ss')
+      row[this.keys.user] = row[this.keys.user] || userInfo.uname
+      return row
+    },
     batchSuccess(response, file, fileList) {
       // 创建完整的行对象，初始化状态字段
       let row = {

package/src/utils/asyncGetRelaNos.js

@@ -1,5 +1,6 @@
 import axios from './axios'
 import { getItem, setItem } from './storageEdit'
+import { persistPermissionItems } from './permissionStorage'
 
 /**
  * @description: 按需/按模块 加载权限
@@ -76,13 +77,21 @@ async function asyncGetRelaNos(appNo, rns) {
     // 将 ssCltrelaNos  重新赋值给 ssCltrelaNos  ,并将 ssCltrelaNos  重新写回到 sessionStorage 中
     // 将 oRelaNos  重新赋值给 ssRelaNosG  ,并将 ssRelaNosG  重新写回到 sessionStorage 中
     // 如果需要同步,则将 isSync  写回到 sessionStorage 中
-    setItem('relaNos', ssRelaNos, isSync)
-    setItem('cltrelaNos', ssCltrelaNos, isSync)
-
     let ssRelaNosG = getItem('relaNosGlobal')
     ssRelaNosG.push(...oRelaNos)
-    setItem('relaNosGlobal', ssRelaNosG, isSync)
-    isSync && sessionStorage.setItem('isSync', isSync)
+
+    if (isSync) {
+      await persistPermissionItems([
+        { key: 'relaNos', value: ssRelaNos },
+        { key: 'cltrelaNos', value: ssCltrelaNos },
+        { key: 'relaNosGlobal', value: ssRelaNosG }
+      ])
+      sessionStorage.setItem('isSync', isSync)
+    } else {
+      setItem('relaNos', ssRelaNos, false)
+      setItem('cltrelaNos', ssCltrelaNos, false)
+      setItem('relaNosGlobal', ssRelaNosG, false)
+    }
   } catch (error) {
     // 如果请求失败，从已加载列表中移除该模块
     const index = RLFM.indexOf(appNo)

package/src/utils/auth.js

@@ -52,7 +52,7 @@ const auth = {
     }
   },
   setReqLang() {
-    let langMap = { 'zh-cn': 'zh_CN', en: 'en_US', 'zh-hk': 'zh_TW', th: 'th_TH', vi: 'vi_VI' }
+    let langMap = { 'zh-cn': 'zh_CN', en: 'en_US', 'zh-hk': 'zh_TW', th: 'th_TH', vi: 'vi_VI', ja: 'ja_JP' }
     let langKey = window.localStorage.getItem('pageLang') || 'zh-cn'
     reqLang = langMap[langKey]
   },

package/src/utils/permission-storage-worker.v1.js

@@ -0,0 +1,296 @@
+/*
+ * 用于 n20 权限存储压缩的专用 Worker。
+ * 压缩算法兼容 lz-string 1.5.0。
+ * 不包含网络、cookie、DOM 或存储访问。
+ */
+;(function () {
+  'use strict'
+
+  var BASE64_ALPHABET =
+    'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='
+
+  function compressToBase64(input) {
+    if (input == null) return ''
+
+    var result = compress(input, 6, function (value) {
+      return BASE64_ALPHABET.charAt(value)
+    })
+
+    switch (result.length % 4) {
+      case 1:
+        return result + '==='
+      case 2:
+        return result + '=='
+      case 3:
+        return result + '='
+      default:
+        return result
+    }
+  }
+
+  function compress(uncompressed, bitsPerChar, getCharFromInt) {
+    if (uncompressed == null) return ''
+
+    var index
+    var value
+    var bitIndex
+    var contextDictionary = {}
+    var contextDictionaryToCreate = {}
+    var contextCharacter = ''
+    var contextWordAndCharacter = ''
+    var contextWord = ''
+    var contextEnlargeIn = 2
+    var contextDictionarySize = 3
+    var contextNumberOfBits = 2
+    var contextData = []
+    var contextDataValue = 0
+    var contextDataPosition = 0
+
+    for (index = 0; index < uncompressed.length; index += 1) {
+      contextCharacter = uncompressed.charAt(index)
+
+      if (
+        !Object.prototype.hasOwnProperty.call(
+          contextDictionary,
+          contextCharacter
+        )
+      ) {
+        contextDictionary[contextCharacter] = contextDictionarySize++
+        contextDictionaryToCreate[contextCharacter] = true
+      }
+
+      contextWordAndCharacter = contextWord + contextCharacter
+      if (
+        Object.prototype.hasOwnProperty.call(
+          contextDictionary,
+          contextWordAndCharacter
+        )
+      ) {
+        contextWord = contextWordAndCharacter
+        continue
+      }
+
+      if (
+        Object.prototype.hasOwnProperty.call(
+          contextDictionaryToCreate,
+          contextWord
+        )
+      ) {
+        if (contextWord.charCodeAt(0) < 256) {
+          for (bitIndex = 0; bitIndex < contextNumberOfBits; bitIndex++) {
+            contextDataValue <<= 1
+            if (contextDataPosition === bitsPerChar - 1) {
+              contextDataPosition = 0
+              contextData.push(getCharFromInt(contextDataValue))
+              contextDataValue = 0
+            } else {
+              contextDataPosition++
+            }
+          }
+
+          value = contextWord.charCodeAt(0)
+          for (bitIndex = 0; bitIndex < 8; bitIndex++) {
+            contextDataValue = (contextDataValue << 1) | (value & 1)
+            if (contextDataPosition === bitsPerChar - 1) {
+              contextDataPosition = 0
+              contextData.push(getCharFromInt(contextDataValue))
+              contextDataValue = 0
+            } else {
+              contextDataPosition++
+            }
+            value >>= 1
+          }
+        } else {
+          value = 1
+          for (bitIndex = 0; bitIndex < contextNumberOfBits; bitIndex++) {
+            contextDataValue = (contextDataValue << 1) | value
+            if (contextDataPosition === bitsPerChar - 1) {
+              contextDataPosition = 0
+              contextData.push(getCharFromInt(contextDataValue))
+              contextDataValue = 0
+            } else {
+              contextDataPosition++
+            }
+            value = 0
+          }
+
+          value = contextWord.charCodeAt(0)
+          for (bitIndex = 0; bitIndex < 16; bitIndex++) {
+            contextDataValue = (contextDataValue << 1) | (value & 1)
+            if (contextDataPosition === bitsPerChar - 1) {
+              contextDataPosition = 0
+              contextData.push(getCharFromInt(contextDataValue))
+              contextDataValue = 0
+            } else {
+              contextDataPosition++
+            }
+            value >>= 1
+          }
+        }
+
+        contextEnlargeIn--
+        if (contextEnlargeIn === 0) {
+          contextEnlargeIn = Math.pow(2, contextNumberOfBits)
+          contextNumberOfBits++
+        }
+        delete contextDictionaryToCreate[contextWord]
+      } else {
+        value = contextDictionary[contextWord]
+        for (bitIndex = 0; bitIndex < contextNumberOfBits; bitIndex++) {
+          contextDataValue = (contextDataValue << 1) | (value & 1)
+          if (contextDataPosition === bitsPerChar - 1) {
+            contextDataPosition = 0
+            contextData.push(getCharFromInt(contextDataValue))
+            contextDataValue = 0
+          } else {
+            contextDataPosition++
+          }
+          value >>= 1
+        }
+      }
+
+      contextEnlargeIn--
+      if (contextEnlargeIn === 0) {
+        contextEnlargeIn = Math.pow(2, contextNumberOfBits)
+        contextNumberOfBits++
+      }
+
+      contextDictionary[contextWordAndCharacter] = contextDictionarySize++
+      contextWord = String(contextCharacter)
+    }
+
+    if (contextWord !== '') {
+      if (
+        Object.prototype.hasOwnProperty.call(
+          contextDictionaryToCreate,
+          contextWord
+        )
+      ) {
+        if (contextWord.charCodeAt(0) < 256) {
+          for (bitIndex = 0; bitIndex < contextNumberOfBits; bitIndex++) {
+            contextDataValue <<= 1
+            if (contextDataPosition === bitsPerChar - 1) {
+              contextDataPosition = 0
+              contextData.push(getCharFromInt(contextDataValue))
+              contextDataValue = 0
+            } else {
+              contextDataPosition++
+            }
+          }
+
+          value = contextWord.charCodeAt(0)
+          for (bitIndex = 0; bitIndex < 8; bitIndex++) {
+            contextDataValue = (contextDataValue << 1) | (value & 1)
+            if (contextDataPosition === bitsPerChar - 1) {
+              contextDataPosition = 0
+              contextData.push(getCharFromInt(contextDataValue))
+              contextDataValue = 0
+            } else {
+              contextDataPosition++
+            }
+            value >>= 1
+          }
+        } else {
+          value = 1
+          for (bitIndex = 0; bitIndex < contextNumberOfBits; bitIndex++) {
+            contextDataValue = (contextDataValue << 1) | value
+            if (contextDataPosition === bitsPerChar - 1) {
+              contextDataPosition = 0
+              contextData.push(getCharFromInt(contextDataValue))
+              contextDataValue = 0
+            } else {
+              contextDataPosition++
+            }
+            value = 0
+          }
+
+          value = contextWord.charCodeAt(0)
+          for (bitIndex = 0; bitIndex < 16; bitIndex++) {
+            contextDataValue = (contextDataValue << 1) | (value & 1)
+            if (contextDataPosition === bitsPerChar - 1) {
+              contextDataPosition = 0
+              contextData.push(getCharFromInt(contextDataValue))
+              contextDataValue = 0
+            } else {
+              contextDataPosition++
+            }
+            value >>= 1
+          }
+        }
+
+        contextEnlargeIn--
+        if (contextEnlargeIn === 0) {
+          contextEnlargeIn = Math.pow(2, contextNumberOfBits)
+          contextNumberOfBits++
+        }
+        delete contextDictionaryToCreate[contextWord]
+      } else {
+        value = contextDictionary[contextWord]
+        for (bitIndex = 0; bitIndex < contextNumberOfBits; bitIndex++) {
+          contextDataValue = (contextDataValue << 1) | (value & 1)
+          if (contextDataPosition === bitsPerChar - 1) {
+            contextDataPosition = 0
+            contextData.push(getCharFromInt(contextDataValue))
+            contextDataValue = 0
+          } else {
+            contextDataPosition++
+          }
+          value >>= 1
+        }
+      }
+
+      contextEnlargeIn--
+      if (contextEnlargeIn === 0) {
+        contextEnlargeIn = Math.pow(2, contextNumberOfBits)
+        contextNumberOfBits++
+      }
+    }
+
+    value = 2
+    for (bitIndex = 0; bitIndex < contextNumberOfBits; bitIndex++) {
+      contextDataValue = (contextDataValue << 1) | (value & 1)
+      if (contextDataPosition === bitsPerChar - 1) {
+        contextDataPosition = 0
+        contextData.push(getCharFromInt(contextDataValue))
+        contextDataValue = 0
+      } else {
+        contextDataPosition++
+      }
+      value >>= 1
+    }
+
+    while (true) {
+      contextDataValue <<= 1
+      if (contextDataPosition === bitsPerChar - 1) {
+        contextData.push(getCharFromInt(contextDataValue))
+        break
+      }
+      contextDataPosition++
+    }
+
+    return contextData.join('')
+  }
+
+  self.onmessage = function (event) {
+    var message = event.data
+    if (
+      !message ||
+      (typeof message.id !== 'number' && typeof message.id !== 'string') ||
+      typeof message.value !== 'string'
+    ) {
+      return
+    }
+
+    try {
+      self.postMessage({
+        id: message.id,
+        compressed: compressToBase64(message.value)
+      })
+    } catch (error) {
+      self.postMessage({
+        id: message.id,
+        error: error && error.message ? error.message : 'Compression failed'
+      })
+    }
+  }
+})()

package/src/utils/permissionStorage.js

@@ -0,0 +1,138 @@
+import PermissionStorageWorker from 'worker-loader?filename=js/permission-storage-worker.[contenthash:8].js!./permission-storage-worker.v1.js'
+import { setItem } from './storageEdit'
+
+const LARGE_STORAGE_THRESHOLD = 524288
+const WORKER_TIMEOUT = 30000
+let compressionWorker = null
+let requestSequence = 0
+const pendingRequests = new Map()
+
+function rejectPendingRequests(error) {
+  pendingRequests.forEach(({ reject, timeoutId }) => {
+    clearTimeout(timeoutId)
+    reject(error)
+  })
+  pendingRequests.clear()
+}
+
+function disposeWorker(error) {
+  if (compressionWorker) {
+    compressionWorker.terminate()
+    compressionWorker = null
+  }
+  rejectPendingRequests(error)
+}
+
+function getCompressionWorker() {
+  if (compressionWorker) return compressionWorker
+  if (typeof Worker === 'undefined') return null
+
+  try {
+    compressionWorker = new PermissionStorageWorker()
+  } catch (error) {
+    compressionWorker = null
+    return null
+  }
+
+  compressionWorker.onmessage = ({ data }) => {
+    if (!data) return
+
+    const pending = pendingRequests.get(data.id)
+    if (!pending) return
+
+    clearTimeout(pending.timeoutId)
+    pendingRequests.delete(data.id)
+
+    if (data.error || typeof data.compressed !== 'string') {
+      pending.reject(new Error(data.error || 'Invalid compression result'))
+      return
+    }
+
+    pending.resolve(data.compressed)
+  }
+
+  compressionWorker.onerror = () => {
+    disposeWorker(new Error('Permission compression worker failed'))
+  }
+
+  return compressionWorker
+}
+
+function compressInWorker(value) {
+  const worker = getCompressionWorker()
+  if (!worker) {
+    return Promise.reject(
+      new Error('Permission compression worker is unavailable')
+    )
+  }
+
+  return new Promise((resolve, reject) => {
+    const id = ++requestSequence
+    const timeoutId = setTimeout(() => {
+      if (!pendingRequests.has(id)) return
+      disposeWorker(new Error('Permission compression worker timed out'))
+    }, WORKER_TIMEOUT)
+
+    pendingRequests.set(id, { resolve, reject, timeoutId })
+    worker.postMessage({ id, value })
+  })
+}
+
+function writeCompressedValue(key, compressed) {
+  const storage = window.sessionStorage
+  const rawSetItem = storage._setItem
+  const rawRemoveItem = storage._removeItem
+
+  if (
+    typeof rawSetItem !== 'function' ||
+    typeof rawRemoveItem !== 'function'
+  ) {
+    throw new Error('Extended Storage API is unavailable')
+  }
+
+  try {
+    rawSetItem.call(storage, `${key}:[LZ]`, compressed)
+    rawRemoveItem.call(storage, key)
+  } catch (error) {
+    // A previous uncompressed value can consume the remaining quota.
+    rawRemoveItem.call(storage, key)
+    rawSetItem.call(storage, `${key}:[LZ]`, compressed)
+  }
+}
+
+async function persistItem({ key, value, serialized }) {
+  if (
+    typeof serialized !== 'string' ||
+    serialized.length <= LARGE_STORAGE_THRESHOLD
+  ) {
+    window.sessionStorage.setItem(key, serialized)
+    return
+  }
+
+  try {
+    const compressed = await compressInWorker(serialized)
+    writeCompressedValue(key, compressed)
+  } catch (error) {
+    // Preserve the existing synchronous behavior when Worker is unavailable.
+    setItem(key, value, true)
+  }
+}
+
+/**
+ * Persist permission objects with the same cache keys and LZ storage format
+ * used by n20-common-lib, while moving large compression work off main thread.
+ */
+export async function persistPermissionItems(items) {
+  const serializedItems = items.map(({ key, value }) => {
+    window[`_keep_${key}`] = value
+    return {
+      key,
+      value,
+      serialized: JSON.stringify(value)
+    }
+  })
+
+  for (const item of serializedItems) {
+    await persistItem(item)
+  }
+}