misp-ui-library-test 0.0.1

package/src/utils/async-validator/index.js

@@ -0,0 +1,659 @@
+/**
+ * 默认校验错误消息模板
+ */
+const defaultMessages = {
+  default: '字段 %s 校验失败',
+  required: '%s 是必填项',
+  enum: '%s 必须是以下值之一: %s',
+  whitespace: '%s 不能为空',
+  date: {
+    format: '%s 日期 %s 不符合格式 %s',
+    parse: '%s 日期无法解析',
+    invalid: '%s 日期 %s 无效',
+  },
+  types: {
+    string: '%s 不是字符串类型',
+    method: '%s 不是函数类型',
+    array: '%s 不是数组类型',
+    object: '%s 不是对象类型',
+    number: '%s 不是数字类型',
+    date: '%s 不是日期类型',
+    boolean: '%s 不是布尔类型',
+    integer: '%s 不是整数类型',
+    float: '%s 不是浮点数类型',
+    url: '%s 不是有效的 URL',
+    hex: '%s 不是有效的十六进制颜色',
+    email: '%s 不是有效的邮箱地址',
+    regexp: '%s 不是有效的正则表达式',
+  },
+  string: {
+    len: '%s 必须正好是 %s 个字符',
+    min: '%s 长度不能少于 %s 个字符',
+    max: '%s 长度不能超过 %s 个字符',
+    range: '%s 长度必须在 %s 到 %s 个字符之间',
+  },
+  number: {
+    len: '%s 必须等于 %s',
+    min: '%s 不能小于 %s',
+    max: '%s 不能大于 %s',
+    range: '%s 必须在 %s 到 %s 之间',
+  },
+  array: {
+    len: '%s 长度必须正好是 %s',
+    min: '%s 长度不能少于 %s',
+    max: '%s 长度不能超过 %s',
+    range: '%s 长度必须在 %s 到 %s 之间',
+  },
+  pattern: {
+    mismatch: '%s 的值 %s 不匹配模式 %s',
+  },
+}
+
+/**
+ * 内置正则表达式模式
+ */
+const pattern = {
+  email: /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9\u007F-\uFFFF]+\.)+[a-zA-Z\u007F-\uFFFF]{2,}))$/,
+  url: /^(?!mailto:)(?:(?:https?|ftp):\/\/|\/\/)(?:\S+(?::\S*)?@)?(?:(?:(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[0-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z\u007f-\uffff0-9]+-?)*[a-z\u007f-\uffff0-9]+)(?:\.(?:[a-z\u007f-\uffff0-9]+-?)*[a-z\u007f-\uffff0-9]+)*(?:\.(?:[a-z\u007f-\uffff]{2,})))|localhost)(?::\d{2,5})?(?:\/[^\s]*)?$/i,
+  hex: /^#?([a-f0-9]{6}|[a-f0-9]{3})$/i,
+  date: /^\d{4}-\d{2}-\d{2}( \d{2}:\d{2}:\d{2}(.\d+)?)?$/,
+  dateObject: Date,
+  digit: /^\d+$/,
+  number: /^-?\d*(\.\d+)?$/,
+  integer: /^-?\d+$/,
+  ipv4: /^(\d{1,2}|1\d\d|2[0-4]\d|25[0-4])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-4])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-4])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-4])$/,
+  ipv6: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/,
+}
+
+/**
+ * 判断值是否为空
+ * @param {*} value - 待检查的值
+ * @returns {boolean} 如果值为 undefined, null, 空字符串或空数组则返回 true
+ */
+function isEmptyValue(value) {
+  if (value === undefined || value === null) {
+    return true
+  }
+  if (typeof value === 'string' && value.trim() === '') {
+    return true
+  }
+  if (Array.isArray(value) && value.length === 0) {
+    return true
+  }
+  return false
+}
+
+/**
+ * 格式化字符串模板，替换 %s占位符
+ * @param {string} template - 包含 %s 占位模板字符串
+ * @param {...*} args - 用于替换占位符的参数
+ * @returns {string} 格式化后的字符串
+ */
+function format(template, ...args) {
+  let result = template
+  for (let i = 0; i < args.length; i++) {
+    result = result.replace('%s', args[i])
+  }
+  return result
+}
+
+/**
+ * 将错误列表按字段分组
+ * @param {Array<ValidateError>} errors - 校验错误列表
+ * @returns {Object|null} 以字段名为键，错误列表为值的对象；如果没有错误则返回 null
+ */
+function convertFieldsError(errors) {
+  if (!errors || errors.length === 0) return null
+  const fields = {}
+  errors.forEach((error) => {
+    const field = error.field
+    fields[field] = fields[field] || []
+    fields[field].push(error)
+  })
+  return fields
+}
+
+/**
+ * 类型校验器集合
+ */
+const typeValidators = {
+  /**
+   * 校验字符串类型
+   * @param {*} value - 待校验值
+   * @returns {boolean}
+   */
+  string(value) {
+    return typeof value === 'string'
+  },
+  /**
+   * 校验数字类型
+   * @param {*} value - 待校验值
+   * @returns {boolean}
+   */
+  number(value) {
+    return typeof value === 'number' && !isNaN(value)
+  },
+  /**
+   * 校验布尔类型
+   * @param {*} value - 待校验值
+   * @returns {boolean}
+   */
+  boolean(value) {
+    return typeof value === 'boolean'
+  },
+  /**
+   * 校验函数类型
+   * @param {*} value - 待校验值
+   * @returns {boolean}
+   */
+  method(value) {
+    return typeof value === 'function'
+  },
+  /**
+   * 校验正则表达式类型
+   * @param {*} value - 待校验值
+   * @returns {boolean}
+   */
+  regexp(value) {
+    return value instanceof RegExp
+  },
+  /**
+   * 校验对象类型（非数组）
+   * @param {*} value - 待校验值
+   * @returns {boolean}
+   */
+  object(value) {
+    return typeof value === 'object' && value !== null && !(value instanceof Array)
+  },
+  /**
+   * 校验整数类型
+   * @param {*} value - 待校验值
+   * @returns {boolean}
+   */
+  integer(value) {
+    return typeof value === 'number' && Number.isInteger(value)
+  },
+  /**
+   * 校验浮点数类型
+   * @param {*} value - 待校验值
+   * @returns {boolean}
+   */
+  float(value) {
+    return typeof value === 'number' && !Number.isInteger(value)
+  },
+  /**
+   * 校验数组类型
+   * @param {*} value - 待校验值
+   * @returns {boolean}
+   */
+  array(value) {
+    return Array.isArray(value)
+  },
+  /**
+   * 校验日期类型
+   * @param {*} value - 待校验值
+   * @returns {boolean}
+   */
+  date(value) {
+    return value instanceof Date && !isNaN(value.getTime())
+  },
+  /**
+   * 校验 URL 格式
+   * @param {*} value - 待校验值
+   * @returns {boolean}
+   */
+  url(value) {
+    return typeof value === 'string' && pattern.url.test(value)
+  },
+  /**
+   * 校验十六进制颜色格式
+   * @param {*} value - 待校验值
+   * @returns {boolean}
+   */
+  hex(value) {
+    return typeof value === 'string' && pattern.hex.test(value)
+  },
+  /**
+   * 校验邮箱格式
+   * @param {*} value - 待校验值
+   * @returns {boolean}
+   */
+  email(value) {
+    return typeof value === 'string' && pattern.email.test(value)
+  },
+  /**
+   * 校验 IPv4 地址格式
+   * @param {*} value - 待校验值
+   * @returns {boolean}
+   */
+  ipv4(value) {
+    return typeof value === 'string' && pattern.ipv4.test(value)
+  },
+  /**
+   * 校验 IPv6 地址格式
+   * @param {*} value - 待校验值
+   * @returns {boolean}
+   */
+  ipv6(value) {
+    return typeof value === 'string' && pattern.ipv6.test(value)
+  },
+}
+
+/**
+ * 校验错误类
+ */
+class ValidateError extends Error {
+  /**
+   * 创建校验错误实例
+   * @param {string} message - 错误消息
+   * @param {string} field - 字段名
+   * @param {string} rule - 规则类型
+   * @param {string} [type='async-validator'] - 错误类型
+   */
+  constructor(message, field, rule, type = 'async-validator') {
+    super(message)
+    this.field = field
+    this.rule = rule
+    this.type = type
+  }
+}
+
+/**
+ * 规则校验器集合
+ */
+const ruleValidators = {
+  /**
+   * 必填项校验
+   * @param {Object} rule - 校验规则
+   * @param {*} value - 待校验值
+   * @param {Object} source - 源数据对象
+   * @param {Array} errors - 错误收集数组
+   * @param {Object} options - 校验选项
+   */
+  required(rule, value, source, errors, options) {
+    if (rule.required && isEmptyValue(value)) {
+      errors.push(new ValidateError(format(rule.message || options.messages.required, rule.field), rule.field, 'required'))
+    }
+  },
+
+  /**
+   * 空白字符校验
+   * @param {Object} rule - 校验规则
+   * @param {*} value - 待校验值
+   * @param {Object} source - 源数据对象
+   * @param {Array} errors - 错误收集数组
+   * @param {Object} options - 校验选项
+   */
+  whitespace(rule, value, source, errors, options) {
+    if (rule.whitespace && typeof value === 'string' && value.trim() === '') {
+      errors.push(new ValidateError(format(rule.message || options.messages.whitespace, rule.field), rule.field, 'whitespace'))
+    }
+  },
+
+  /**
+   * 类型校验
+   * @param {Object} rule - 校验规则
+   * @param {*} value - 待校验值
+   * @param {Object} source - 源数据对象
+   * @param {Array} errors - 错误收集数组
+   * @param {Object} options - 校验选项
+   */
+  type(rule, value, source, errors, options) {
+    if (rule.type && typeValidators[rule.type]) {
+      const validator = typeValidators[rule.type]
+      if (!validator(value)) {
+        errors.push(new ValidateError(format(rule.message || options.messages.types[rule.type], rule.field, rule.type), rule.field, 'type'))
+      }
+    }
+  },
+
+  /**
+   * 正则表达式匹配校验
+   * @param {Object} rule - 校验规则
+   * @param {*} value - 待校验值
+   * @param {Object} source - 源数据对象
+   * @param {Array} errors - 错误收集数组
+   * @param {Object} options - 校验选项
+   */
+  pattern(rule, value, source, errors, options) {
+    if (rule.pattern && typeof value === 'string') {
+      const regexp = rule.pattern instanceof RegExp ? rule.pattern : new RegExp(rule.pattern)
+      if (!regexp.test(value)) {
+        errors.push(new ValidateError(format(rule.message || options.messages.pattern.mismatch, rule.field, value, rule.pattern), rule.field, 'pattern'))
+      }
+    }
+  },
+
+  /**
+   * 范围/长度校验
+   * @param {Object} rule - 校验规则
+   * @param {*} value - 待校验值
+   * @param {Object} source - 源数据对象
+   * @param {Array} errors - 错误收集数组
+   * @param {Object} options - 校验选项
+   */
+  range(rule, value, source, errors, options) {
+    if (typeof value === 'string' || Array.isArray(value)) {
+      const len = value.length
+      if (rule.len !== undefined && len !== rule.len) {
+        errors.push(new ValidateError(format(rule.message || options.messages[typeof value === 'string' ? 'string' : 'array'].len, rule.field, rule.len), rule.field, 'len'))
+      }
+      if (rule.min !== undefined && len < rule.min) {
+        errors.push(new ValidateError(format(rule.message || options.messages[typeof value === 'string' ? 'string' : 'array'].min, rule.field, rule.min), rule.field, 'min'))
+      }
+      if (rule.max !== undefined && len > rule.max) {
+        errors.push(new ValidateError(format(rule.message || options.messages[typeof value === 'string' ? 'string' : 'array'].max, rule.field, rule.max), rule.field, 'max'))
+      }
+    } else if (typeof value === 'number') {
+      if (rule.len !== undefined && value !== rule.len) {
+        errors.push(new ValidateError(format(rule.message || options.messages.number.len, rule.field, rule.len), rule.field, 'len'))
+      }
+      if (rule.min !== undefined && value < rule.min) {
+        errors.push(new ValidateError(format(rule.message || options.messages.number.min, rule.field, rule.min), rule.field, 'min'))
+      }
+      if (rule.max !== undefined && value > rule.max) {
+        errors.push(new ValidateError(format(rule.message || options.messages.number.max, rule.field, rule.max), rule.field, 'max'))
+      }
+    }
+  },
+
+  /**
+   * 枚举值校验
+   * @param {Object} rule - 校验规则
+   * @param {*} value - 待校验值
+   * @param {Object} source - 源数据对象
+   * @param {Array} errors - 错误收集数组
+   * @param {Object} options - 校验选项
+   */
+  enum(rule, value, source, errors, options) {
+    if (rule.enum && rule.enum.length > 0) {
+      if (!rule.enum.includes(value)) {
+        errors.push(new ValidateError(format(rule.message || options.messages.enum, rule.field, JSON.stringify(rule.enum)), rule.field, 'enum'))
+      }
+    }
+  },
+
+  /**
+   * 自定义校验器 (完全兼容 Element UI 风格: 同步返回 或 异步 callback)
+   * @param {Object} rule - 校验规则
+   * @param {*} value - 待校验值
+   * @param {Object} source - 源数据对象
+   * @param {Array} errors - 错误收集数组
+   * @param {Object} options - 校验选项
+   * @returns {Promise<void>}
+   */
+  validator(rule, value, source, errors, options) {
+    if (!rule.validator || typeof rule.validator !== 'function') {
+      return Promise.resolve()
+    }
+
+    return new Promise(async (resolve) => {
+      let called = false
+      const cb = (err) => {
+        if (called) return
+        called = true
+        
+        if (err instanceof Error) {
+          errors.push(err)
+        } else if (typeof err === 'string') {
+          errors.push(new ValidateError(err, rule.field, 'validator'))
+        } else if (err) {
+          // 兼容其他真值错误
+          errors.push(new ValidateError(format(defaultMessages.default, rule.field), rule.field, 'validator'))
+        }
+        resolve()
+      }
+
+      try {
+        // 调用用户定义的 validator: (rule, value, callback)
+        // 注意：Element UI 标准签名只有3个参数，但我们传入 callback 即可
+        const res = await rule.validator(rule, value, cb)
+
+        // 处理同步返回的情况
+        // 如果用户没有调用 callback，而是直接返回了结果
+        if (!called) {
+          if (res === false) {
+            errors.push(new ValidateError(
+              typeof rule.message === 'function' ? rule.message(rule.field) : (rule.message || format(defaultMessages.default, rule.field)),
+              rule.field,
+              'validator'
+            ))
+          } else if (res instanceof Error) {
+            errors.push(res)
+          }
+          // 同步完成，立即 resolve
+          resolve()
+        }
+        // 如果调用了 cb，cb 内部会调用 resolve()
+      } catch (e) {
+        if (!called) {
+          errors.push(e instanceof Error ? e : new ValidateError(String(e), rule.field, 'validator'))
+          resolve()
+        }
+      }
+    })
+  },
+}
+
+/**
+ * 校验 Schema 主类
+ */
+class Schema {
+  /**
+   * 创建 Schema 实例
+   * @param {Object} descriptor - 校验描述符对象
+   * @param {Object} [options={}] - 配置选项
+   */
+  constructor(descriptor, options = {}) {
+    this.define(descriptor)
+    this.messages = Object.assign({}, defaultMessages, options.messages)
+    this.options = options
+  }
+
+  /**
+   * 定义校验描述符
+   * @param {Object} descriptor - 校验描述符对象
+   * @returns {Schema} 当前实例，支持链式调用
+   */
+  define(descriptor) {
+    this.descriptor = descriptor
+    return this
+  }
+
+  /**
+   * 设置或获取校验消息
+   * @param {Object} [messages] - 新的消息模板对象
+   * @returns {Object|void} 如果传入 messages 则无返回值，否则返回当前消息对象
+   */
+  messages(messages) {
+    if (messages) {
+      this.messages = Object.assign({}, this.messages, messages)
+    }
+    return this.messages
+  }
+
+  /**
+   * 执行校验
+   * @param {Object} source - 待校验的数据源
+   * @param {Object|Function} [o] - 校验选项或回调函数
+   * @param {Function} [cb] - 回调函数
+   * @returns {Promise<Object>} 校验结果 Promise
+   */
+  validate(source, o, cb) {
+    if (typeof o === 'function') {
+      cb = o
+      o = {}
+    }
+
+    const options = o || {}
+    const messages = Object.assign({}, this.messages, options.messages)
+    const keys = options.keys || Object.keys(this.descriptor)
+
+    options.messages = messages
+    options.first = options.first || false
+    options.firstFields = options.firstFields || false
+
+    const errors = []
+    
+    // 用于收集所有字段的校验 Promise
+    const pendingValidations = []
+
+    keys.forEach((key) => {
+      const descriptor = this.descriptor[key]
+      const rules = Array.isArray(descriptor) ? descriptor : [descriptor]
+      const value = source[key]
+
+      // 为每个字段创建一个校验 Promise
+      const fieldValidationPromise = new Promise((resolveField) => {
+        const fieldErrors = []
+        let processedRuleCount = 0
+        const totalRules = rules.length
+
+        // 如果没有任何规则，直接 resolve
+        if (totalRules === 0) {
+          resolveField([])
+          return
+        }
+
+        rules.forEach((rule) => {
+          // 标准化 rule 对象
+          const ruleWithOptions = Object.assign({}, rule, {
+            key: key,
+            field: rule.field || key,
+            fullField: rule.fullField || rule.field || key,
+          })
+
+          const ruleErrors = []
+          
+          // 运行内置同步校验器 (required, type, pattern, etc.)
+          // 这些仍然是同步执行的，直接填充 ruleErrors
+          Object.keys(ruleValidators).forEach((vKey) => {
+            // 跳过自定义 validator/asyncValidator，稍后单独处理
+            if (vKey === 'validator' || vKey === 'asyncValidator') return
+            
+            if (rule.hasOwnProperty(vKey) || vKey === 'required') {
+              ruleValidators[vKey](ruleWithOptions, value, source, ruleErrors, options)
+            }
+          })
+
+          // 处理自定义 validator (支持异步)
+          let customValidatorPromise = Promise.resolve()
+          
+          if (rule.validator && typeof rule.validator === 'function') {
+            // 使用我们改造后的 validator，它返回 Promise
+            customValidatorPromise = ruleValidators.validator(ruleWithOptions, value, source, ruleErrors, options)
+          } else if (rule.asyncValidator && typeof rule.asyncValidator === 'function') {
+             // 兼容旧的 asyncValidator 字段
+             customValidatorPromise = ruleValidators.asyncValidator(ruleWithOptions, value, source, ruleErrors, options)
+          }
+
+          // 等待自定义校验完成，然后汇总结果
+          customValidatorPromise.then(() => {
+            // 将当前规则的 errors 加入字段 errors
+            if (ruleErrors.length > 0) {
+              fieldErrors.push(...ruleErrors)
+            }
+            
+            processedRuleCount++
+            
+            // 如果所有规则都处理完了，resolve 该字段的 Promise
+            if (processedRuleCount === totalRules) {
+              resolveField(fieldErrors)
+            }
+          }).catch(err => {
+             // 防止 Promise  reject 导致中断
+             console.error('Validation error:', err)
+             processedRuleCount++
+             if (processedRuleCount === totalRules) {
+               resolveField(fieldErrors)
+             }
+          })
+        })
+      })
+
+      pendingValidations.push(fieldValidationPromise.then((fieldErrors) => {
+        if (fieldErrors && fieldErrors.length > 0) {
+          errors.push(...fieldErrors)
+        }
+      }))
+    })
+
+    // 等待所有字段校验完成
+    return Promise.all(pendingValidations).then(() => {
+      if (errors.length > 0) {
+        const fields = convertFieldsError(errors)
+        if (cb) {
+          cb(errors, fields)
+        } else {
+          return Promise.reject({ errors, fields })
+        }
+      } else {
+        if (cb) {
+          cb(null, source)
+        } else {
+          return source
+        }
+      }
+    })
+  }
+
+  /**
+   * 校验指定字段
+   * @param {string|Array<string>} fields - 要校验的字段名或字段名数组
+   * @param {Object} source - 待校验的数据源
+   * @param {Object|Function} [o] - 校验选项或回调函数
+   * @param {Function} [cb] - 回调函数
+   * @returns {Promise<Object>} 校验结果 Promise
+   */
+  async validateField(fields, source, o, cb) {
+    if (typeof o === 'function') {
+      cb = o
+      o = {}
+    }
+
+    const options = o || {}
+    const keys = Array.isArray(fields) ? fields : [fields]
+
+    return this.validate(source, { ...options, keys }, cb)
+  }
+
+  /**
+   * 获取单个字段的规则
+   * @param {string} ruleKey - 规则键名
+   * @param {string} fullField - 完整字段名
+   * @returns {Array<Object>} 规则列表
+   */
+  getRule(ruleKey, fullField) {
+    const rule = this.descriptor[ruleKey]
+    if (rule) {
+      if (Array.isArray(rule)) {
+        return rule.map((r) => ({ ...r, field: fullField }))
+      }
+      return [{ ...rule, field: fullField }]
+    }
+    return []
+  }
+
+  /**
+   * 获取多个字段的规则
+   * @param {Array<string>} ruleKeys - 规则键名数组
+   * @param {Array<string>} fullFields - 完整字段名数组
+   * @returns {Array<Object>} 规则列表
+   */
+  getRules(ruleKeys, fullFields) {
+    const rules = []
+    ruleKeys.forEach((key, index) => {
+      const fieldRules = this.getRule(key, fullFields[index] || key)
+      rules.push(...fieldRules)
+    })
+    return rules
+  }
+}
+
+// 静态属性
+Schema.pattern = pattern
+Schema.messages = defaultMessages
+
+// 导出
+export default Schema
+export { Schema, pattern, defaultMessages, typeValidators }

package/src/utils/browser/index.js

@@ -0,0 +1,39 @@
+/**
+ * @module utils/browser
+ * @description 提供浏览器环境检测工具函数
+ */
+import Vue from 'vue';
+
+/**
+ * 检测当前浏览器是否为 IE
+ * @function isIE
+ * @memberof module:utils/browser
+ * @returns {Boolean} 如果是 IE 浏览器返回 true，否则返回 false
+ * @description 通过 document.documentMode 属性判断，仅在不处于服务端渲染(SSR)环境下有效
+ */
+export const isIE = function() {
+  return !Vue.prototype.$isServer && !isNaN(Number(document.documentMode));
+};
+
+/**
+ * 检测当前浏览器是否为 Edge (旧版 EdgeHTML 内核)
+ * @function isEdge
+ * @memberof module:utils/browser
+ * @returns {Boolean} 如果是 Edge 浏览器返回 true，否则返回 false
+ * @description 通过 User-Agent 中包含 'Edge' 字符串判断，仅在不处于服务端渲染(SSR)环境下有效
+ * @note 注意：此方法主要检测基于 EdgeHTML 的旧版 Edge，新版 Chromium Edge 可能不被识别或需额外判断
+ */
+export const isEdge = function() {
+  return !Vue.prototype.$isServer && navigator.userAgent.indexOf('Edge') > -1;
+};
+
+/**
+ * 检测当前浏览器是否为 Firefox
+ * @function isFirefox
+ * @memberof module:utils/browser
+ * @returns {Boolean} 如果是 Firefox 浏览器返回 true，否则返回 false
+ * @description 通过 User-Agent 中匹配 'firefox' 字符串判断（不区分大小写），仅在不处于服务端渲染(SSR)环境下有效
+ */
+export const isFirefox = function() {
+  return !Vue.prototype.$isServer && !!window.navigator.userAgent.match(/firefox/i);
+};