n20-common-lib 3.2.42 → 3.2.43

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n20-common-lib",
-  "version": "3.2.42",
+  "version": "3.2.43",
   "private": false,
   "scripts": {
     "serve": "pnpm --dir ../packages/docs run serve",
@@ -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/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/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)
+  }
+}