chore: initial import

utils/enum-store.js

@@ -0,0 +1,167 @@
+import { getEnums } from '@/api/index.js'
+import { getCurrentLanguage } from '@/utils/i18n'
+
+const ENUMS_CACHE_KEY = 'mini_enums_cache_v1'
+
+let enumsMap = {}
+let enumsLanguage = ''
+let fetchPromise = null
+
+function normalizeEnumMap(data) {
+  const map = {}
+  if (Array.isArray(data)) {
+    data.forEach((item) => {
+      if (item && item.code) {
+        map[item.code] = Array.isArray(item.data) ? item.data : []
+      }
+    })
+  }
+  return map
+}
+
+function getNormalizedLanguage(language = '') {
+  return String(language || getCurrentLanguage() || 'zh').trim().toLowerCase() === 'en' ? 'en' : 'zh'
+}
+
+function readEnumsCache(language) {
+  const cacheLanguage = getNormalizedLanguage(language)
+  try {
+    const cached = uni.getStorageSync(ENUMS_CACHE_KEY)
+    if (!cached) return {}
+    const resolveLanguageBucket = (payload) => {
+      if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        return {}
+      }
+      if (payload.en || payload.zh) {
+        const bucket = payload[cacheLanguage]
+        return bucket && typeof bucket === 'object' ? bucket : {}
+      }
+      return payload
+    }
+    if (typeof cached === 'string') {
+      const parsed = JSON.parse(cached)
+      return resolveLanguageBucket(parsed)
+    }
+    return resolveLanguageBucket(cached)
+  } catch (error) {
+    console.error('Failed to read enums cache', error)
+    return {}
+  }
+}
+
+function writeEnumsCache(map, language) {
+  const cacheLanguage = getNormalizedLanguage(language)
+  try {
+    const cached = uni.getStorageSync(ENUMS_CACHE_KEY)
+    let nextCache = {}
+    if (cached && typeof cached === 'object' && !Array.isArray(cached)) {
+      nextCache = { ...cached }
+    } else if (typeof cached === 'string') {
+      try {
+        const parsed = JSON.parse(cached)
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+          nextCache = { ...parsed }
+        }
+      } catch (error) {
+        nextCache = {}
+      }
+    }
+    nextCache[cacheLanguage] = map
+    uni.setStorageSync(ENUMS_CACHE_KEY, nextCache)
+  } catch (error) {
+    console.error('Failed to write enums cache', error)
+  }
+}
+
+export function initEnumsFromCache(language) {
+  const currentLanguage = getNormalizedLanguage(language)
+  if (Object.keys(enumsMap).length && enumsLanguage === currentLanguage) return enumsMap
+  enumsMap = readEnumsCache(currentLanguage)
+  enumsLanguage = currentLanguage
+  return enumsMap
+}
+
+export async function fetchEnums(force = false, language) {
+  const currentLanguage = getNormalizedLanguage(language)
+  if (!force && Object.keys(enumsMap).length && enumsLanguage === currentLanguage) return enumsMap
+  if (fetchPromise) return fetchPromise
+
+  fetchPromise = (async () => {
+    if (!force && (!Object.keys(enumsMap).length || enumsLanguage !== currentLanguage)) {
+      initEnumsFromCache(currentLanguage)
+      if (Object.keys(enumsMap).length) return enumsMap
+    }
+
+    try {
+      const res = await getEnums({}, currentLanguage)
+      const data = res && res.data ? res.data : res
+      const map = normalizeEnumMap(data)
+      if (Object.keys(map).length) {
+        enumsMap = map
+        enumsLanguage = currentLanguage
+        writeEnumsCache(map, currentLanguage)
+      }
+      return enumsMap
+    } catch (error) {
+      console.error('Failed to fetch enums', error)
+      return enumsMap
+    } finally {
+      fetchPromise = null
+    }
+  })()
+
+  return fetchPromise
+}
+
+export function getEnumOptions(code, language) {
+  initEnumsFromCache(language)
+  return enumsMap[code] || []
+}
+
+export function getEnumLabel(code, key, fallback = '', language) {
+  const options = getEnumOptions(code, language)
+  const matched = options.find(item => String(item.key) === String(key))
+  if (matched) return matched.value
+  return fallback || key
+}
+
+export function getApprovalStatusLabel(status, fallback = '', language) {
+  return getEnumLabel('ApprovalStatusEnum', status, fallback, language)
+}
+
+export function getGenderLabel(gender, fallback = '', language) {
+  return getEnumLabel('GenderEnum', gender, fallback, language)
+}
+
+export const ACCOUNT_BILL_STATUS = {
+  ACTIVE: 10,
+  FINISHED: 99
+}
+
+export const ACCOUNT_BILL_PAYMENT_STATUS = {
+  UNPAID: 0,
+  PARTIAL: 1,
+  PAID: 2
+}
+
+export const ACCOUNT_BILL_REFUND_STATUS = {
+  NONE: 0,
+  PARTIAL: 10,
+  REFUNDED: 99
+}
+
+export function getAccountBillStatusLabel(status, fallback = '', language) {
+  return getEnumLabel('AccountBillStatusEnum', status, fallback, language)
+}
+
+export function getAccountBillPaymentStatusLabel(status, fallback = '', language) {
+  return getEnumLabel('AccountBillPaymentStatusEnum', status, fallback, language)
+}
+
+export function getAccountBillRefundStatusLabel(status, fallback = '', language) {
+  return getEnumLabel('AccountBillRefundStatusEnum', status, fallback, language)
+}
+
+export function getAccountReferenceTypeLabel(type, fallback = '', language) {
+  return getEnumLabel('AccountReferenceTypeEnum', type, fallback, language)
+}