rexma-design 0.0.1

package/index.ts

@@ -0,0 +1 @@
+export { default as XinhuaClient } from './utils/XinhuaClient/index';

package/lib/md5.js

@@ -0,0 +1,370 @@
+/*
+ * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
+ * Digest Algorithm, as defined in RFC 1321.
+ * Version 2.2 Copyright (C) Paul Johnston 1999 - 2009
+ * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+ * Distributed under the BSD License
+ * See http://pajhome.org.uk/crypt/md5 for more info.
+ */
+
+/*
+ * Configurable variables. You may need to tweak these to be compatible with
+ * the server-side, but the defaults work in most cases.
+ */
+var hexcase = 0; /* hex output format. 0 - lowercase; 1 - uppercase        */
+var b64pad = ''; /* base-64 pad character. "=" for strict RFC compliance   */
+
+/*
+ * These are the functions you'll usually want to call
+ * They take string arguments and return either hex or base-64 encoded strings
+ */
+function hex_md5(s) {
+  return rstr2hex(rstr_md5(str2rstr_utf8(s)));
+}
+function b64_md5(s) {
+  return rstr2b64(rstr_md5(str2rstr_utf8(s)));
+}
+function any_md5(s, e) {
+  return rstr2any(rstr_md5(str2rstr_utf8(s)), e);
+}
+function hex_hmac_md5(k, d) {
+  return rstr2hex(rstr_hmac_md5(str2rstr_utf8(k), str2rstr_utf8(d)));
+}
+function b64_hmac_md5(k, d) {
+  return rstr2b64(rstr_hmac_md5(str2rstr_utf8(k), str2rstr_utf8(d)));
+}
+function any_hmac_md5(k, d, e) {
+  return rstr2any(rstr_hmac_md5(str2rstr_utf8(k), str2rstr_utf8(d)), e);
+}
+
+/*
+ * Perform a simple self-test to see if the VM is working
+ */
+function md5_vm_test() {
+  return hex_md5('abc').toLowerCase() == '900150983cd24fb0d6963f7d28e17f72';
+}
+
+/*
+ * Calculate the MD5 of a raw string
+ */
+function rstr_md5(s) {
+  return binl2rstr(binl_md5(rstr2binl(s), s.length * 8));
+}
+
+/*
+ * Calculate the HMAC-MD5, of a key and some data (raw strings)
+ */
+function rstr_hmac_md5(key, data) {
+  var bkey = rstr2binl(key);
+  if (bkey.length > 16) bkey = binl_md5(bkey, key.length * 8);
+
+  var ipad = Array(16),
+    opad = Array(16);
+  for (var i = 0; i < 16; i++) {
+    ipad[i] = bkey[i] ^ 0x36363636;
+    opad[i] = bkey[i] ^ 0x5c5c5c5c;
+  }
+
+  var hash = binl_md5(ipad.concat(rstr2binl(data)), 512 + data.length * 8);
+  return binl2rstr(binl_md5(opad.concat(hash), 512 + 128));
+}
+
+/*
+ * Convert a raw string to a hex string
+ */
+function rstr2hex(input) {
+  try {
+    hexcase;
+  } catch (e) {
+    hexcase = 0;
+  }
+  var hex_tab = hexcase ? '0123456789ABCDEF' : '0123456789abcdef';
+  var output = '';
+  var x;
+  for (var i = 0; i < input.length; i++) {
+    x = input.charCodeAt(i);
+    output += hex_tab.charAt((x >>> 4) & 0x0f) + hex_tab.charAt(x & 0x0f);
+  }
+  return output;
+}
+
+/*
+ * Convert a raw string to a base-64 string
+ */
+function rstr2b64(input) {
+  try {
+    b64pad;
+  } catch (e) {
+    b64pad = '';
+  }
+  var tab = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+  var output = '';
+  var len = input.length;
+  for (var i = 0; i < len; i += 3) {
+    var triplet =
+      (input.charCodeAt(i) << 16) |
+      (i + 1 < len ? input.charCodeAt(i + 1) << 8 : 0) |
+      (i + 2 < len ? input.charCodeAt(i + 2) : 0);
+    for (var j = 0; j < 4; j++) {
+      if (i * 8 + j * 6 > input.length * 8) output += b64pad;
+      else output += tab.charAt((triplet >>> (6 * (3 - j))) & 0x3f);
+    }
+  }
+  return output;
+}
+
+/*
+ * Convert a raw string to an arbitrary string encoding
+ */
+function rstr2any(input, encoding) {
+  var divisor = encoding.length;
+  var i, j, q, x, quotient;
+
+  /* Convert to an array of 16-bit big-endian values, forming the dividend */
+  var dividend = Array(Math.ceil(input.length / 2));
+  for (i = 0; i < dividend.length; i++) {
+    dividend[i] = (input.charCodeAt(i * 2) << 8) | input.charCodeAt(i * 2 + 1);
+  }
+
+  /*
+   * Repeatedly perform a long division. The binary array forms the dividend,
+   * the length of the encoding is the divisor. Once computed, the quotient
+   * forms the dividend for the next step. All remainders are stored for later
+   * use.
+   */
+  var full_length = Math.ceil((input.length * 8) / (Math.log(encoding.length) / Math.log(2)));
+  var remainders = Array(full_length);
+  for (j = 0; j < full_length; j++) {
+    quotient = Array();
+    x = 0;
+    for (i = 0; i < dividend.length; i++) {
+      x = (x << 16) + dividend[i];
+      q = Math.floor(x / divisor);
+      x -= q * divisor;
+      if (quotient.length > 0 || q > 0) quotient[quotient.length] = q;
+    }
+    remainders[j] = x;
+    dividend = quotient;
+  }
+
+  /* Convert the remainders to the output string */
+  var output = '';
+  for (i = remainders.length - 1; i >= 0; i--) output += encoding.charAt(remainders[i]);
+
+  return output;
+}
+
+/*
+ * Encode a string as utf-8.
+ * For efficiency, this assumes the input is valid utf-16.
+ */
+function str2rstr_utf8(input) {
+  var output = '';
+  var i = -1;
+  var x, y;
+
+  while (++i < input.length) {
+    /* Decode utf-16 surrogate pairs */
+    x = input.charCodeAt(i);
+    y = i + 1 < input.length ? input.charCodeAt(i + 1) : 0;
+    if (0xd800 <= x && x <= 0xdbff && 0xdc00 <= y && y <= 0xdfff) {
+      x = 0x10000 + ((x & 0x03ff) << 10) + (y & 0x03ff);
+      i++;
+    }
+
+    /* Encode output as utf-8 */
+    if (x <= 0x7f) output += String.fromCharCode(x);
+    else if (x <= 0x7ff)
+      output += String.fromCharCode(0xc0 | ((x >>> 6) & 0x1f), 0x80 | (x & 0x3f));
+    else if (x <= 0xffff)
+      output += String.fromCharCode(
+        0xe0 | ((x >>> 12) & 0x0f),
+        0x80 | ((x >>> 6) & 0x3f),
+        0x80 | (x & 0x3f),
+      );
+    else if (x <= 0x1fffff)
+      output += String.fromCharCode(
+        0xf0 | ((x >>> 18) & 0x07),
+        0x80 | ((x >>> 12) & 0x3f),
+        0x80 | ((x >>> 6) & 0x3f),
+        0x80 | (x & 0x3f),
+      );
+  }
+  return output;
+}
+
+/*
+ * Encode a string as utf-16
+ */
+function str2rstr_utf16le(input) {
+  var output = '';
+  for (var i = 0; i < input.length; i++)
+    output += String.fromCharCode(input.charCodeAt(i) & 0xff, (input.charCodeAt(i) >>> 8) & 0xff);
+  return output;
+}
+
+function str2rstr_utf16be(input) {
+  var output = '';
+  for (var i = 0; i < input.length; i++)
+    output += String.fromCharCode((input.charCodeAt(i) >>> 8) & 0xff, input.charCodeAt(i) & 0xff);
+  return output;
+}
+
+/*
+ * Convert a raw string to an array of little-endian words
+ * Characters >255 have their high-byte silently ignored.
+ */
+function rstr2binl(input) {
+  var output = Array(input.length >> 2);
+  for (var i = 0; i < output.length; i++) output[i] = 0;
+  for (var i = 0; i < input.length * 8; i += 8)
+    output[i >> 5] |= (input.charCodeAt(i / 8) & 0xff) << i % 32;
+  return output;
+}
+
+/*
+ * Convert an array of little-endian words to a string
+ */
+function binl2rstr(input) {
+  var output = '';
+  for (var i = 0; i < input.length * 32; i += 8)
+    output += String.fromCharCode((input[i >> 5] >>> i % 32) & 0xff);
+  return output;
+}
+
+/*
+ * Calculate the MD5 of an array of little-endian words, and a bit length.
+ */
+function binl_md5(x, len) {
+  /* append padding */
+  x[len >> 5] |= 0x80 << len % 32;
+  x[(((len + 64) >>> 9) << 4) + 14] = len;
+
+  var a = 1732584193;
+  var b = -271733879;
+  var c = -1732584194;
+  var d = 271733878;
+
+  for (var i = 0; i < x.length; i += 16) {
+    var olda = a;
+    var oldb = b;
+    var oldc = c;
+    var oldd = d;
+
+    a = md5_ff(a, b, c, d, x[i + 0], 7, -680876936);
+    d = md5_ff(d, a, b, c, x[i + 1], 12, -389564586);
+    c = md5_ff(c, d, a, b, x[i + 2], 17, 606105819);
+    b = md5_ff(b, c, d, a, x[i + 3], 22, -1044525330);
+    a = md5_ff(a, b, c, d, x[i + 4], 7, -176418897);
+    d = md5_ff(d, a, b, c, x[i + 5], 12, 1200080426);
+    c = md5_ff(c, d, a, b, x[i + 6], 17, -1473231341);
+    b = md5_ff(b, c, d, a, x[i + 7], 22, -45705983);
+    a = md5_ff(a, b, c, d, x[i + 8], 7, 1770035416);
+    d = md5_ff(d, a, b, c, x[i + 9], 12, -1958414417);
+    c = md5_ff(c, d, a, b, x[i + 10], 17, -42063);
+    b = md5_ff(b, c, d, a, x[i + 11], 22, -1990404162);
+    a = md5_ff(a, b, c, d, x[i + 12], 7, 1804603682);
+    d = md5_ff(d, a, b, c, x[i + 13], 12, -40341101);
+    c = md5_ff(c, d, a, b, x[i + 14], 17, -1502002290);
+    b = md5_ff(b, c, d, a, x[i + 15], 22, 1236535329);
+
+    a = md5_gg(a, b, c, d, x[i + 1], 5, -165796510);
+    d = md5_gg(d, a, b, c, x[i + 6], 9, -1069501632);
+    c = md5_gg(c, d, a, b, x[i + 11], 14, 643717713);
+    b = md5_gg(b, c, d, a, x[i + 0], 20, -373897302);
+    a = md5_gg(a, b, c, d, x[i + 5], 5, -701558691);
+    d = md5_gg(d, a, b, c, x[i + 10], 9, 38016083);
+    c = md5_gg(c, d, a, b, x[i + 15], 14, -660478335);
+    b = md5_gg(b, c, d, a, x[i + 4], 20, -405537848);
+    a = md5_gg(a, b, c, d, x[i + 9], 5, 568446438);
+    d = md5_gg(d, a, b, c, x[i + 14], 9, -1019803690);
+    c = md5_gg(c, d, a, b, x[i + 3], 14, -187363961);
+    b = md5_gg(b, c, d, a, x[i + 8], 20, 1163531501);
+    a = md5_gg(a, b, c, d, x[i + 13], 5, -1444681467);
+    d = md5_gg(d, a, b, c, x[i + 2], 9, -51403784);
+    c = md5_gg(c, d, a, b, x[i + 7], 14, 1735328473);
+    b = md5_gg(b, c, d, a, x[i + 12], 20, -1926607734);
+
+    a = md5_hh(a, b, c, d, x[i + 5], 4, -378558);
+    d = md5_hh(d, a, b, c, x[i + 8], 11, -2022574463);
+    c = md5_hh(c, d, a, b, x[i + 11], 16, 1839030562);
+    b = md5_hh(b, c, d, a, x[i + 14], 23, -35309556);
+    a = md5_hh(a, b, c, d, x[i + 1], 4, -1530992060);
+    d = md5_hh(d, a, b, c, x[i + 4], 11, 1272893353);
+    c = md5_hh(c, d, a, b, x[i + 7], 16, -155497632);
+    b = md5_hh(b, c, d, a, x[i + 10], 23, -1094730640);
+    a = md5_hh(a, b, c, d, x[i + 13], 4, 681279174);
+    d = md5_hh(d, a, b, c, x[i + 0], 11, -358537222);
+    c = md5_hh(c, d, a, b, x[i + 3], 16, -722521979);
+    b = md5_hh(b, c, d, a, x[i + 6], 23, 76029189);
+    a = md5_hh(a, b, c, d, x[i + 9], 4, -640364487);
+    d = md5_hh(d, a, b, c, x[i + 12], 11, -421815835);
+    c = md5_hh(c, d, a, b, x[i + 15], 16, 530742520);
+    b = md5_hh(b, c, d, a, x[i + 2], 23, -995338651);
+
+    a = md5_ii(a, b, c, d, x[i + 0], 6, -198630844);
+    d = md5_ii(d, a, b, c, x[i + 7], 10, 1126891415);
+    c = md5_ii(c, d, a, b, x[i + 14], 15, -1416354905);
+    b = md5_ii(b, c, d, a, x[i + 5], 21, -57434055);
+    a = md5_ii(a, b, c, d, x[i + 12], 6, 1700485571);
+    d = md5_ii(d, a, b, c, x[i + 3], 10, -1894986606);
+    c = md5_ii(c, d, a, b, x[i + 10], 15, -1051523);
+    b = md5_ii(b, c, d, a, x[i + 1], 21, -2054922799);
+    a = md5_ii(a, b, c, d, x[i + 8], 6, 1873313359);
+    d = md5_ii(d, a, b, c, x[i + 15], 10, -30611744);
+    c = md5_ii(c, d, a, b, x[i + 6], 15, -1560198380);
+    b = md5_ii(b, c, d, a, x[i + 13], 21, 1309151649);
+    a = md5_ii(a, b, c, d, x[i + 4], 6, -145523070);
+    d = md5_ii(d, a, b, c, x[i + 11], 10, -1120210379);
+    c = md5_ii(c, d, a, b, x[i + 2], 15, 718787259);
+    b = md5_ii(b, c, d, a, x[i + 9], 21, -343485551);
+
+    a = safe_add(a, olda);
+    b = safe_add(b, oldb);
+    c = safe_add(c, oldc);
+    d = safe_add(d, oldd);
+  }
+  return Array(a, b, c, d);
+}
+
+/*
+ * These functions implement the four basic operations the algorithm uses.
+ */
+function md5_cmn(q, a, b, x, s, t) {
+  return safe_add(bit_rol(safe_add(safe_add(a, q), safe_add(x, t)), s), b);
+}
+function md5_ff(a, b, c, d, x, s, t) {
+  return md5_cmn((b & c) | (~b & d), a, b, x, s, t);
+}
+function md5_gg(a, b, c, d, x, s, t) {
+  return md5_cmn((b & d) | (c & ~d), a, b, x, s, t);
+}
+function md5_hh(a, b, c, d, x, s, t) {
+  return md5_cmn(b ^ c ^ d, a, b, x, s, t);
+}
+function md5_ii(a, b, c, d, x, s, t) {
+  return md5_cmn(c ^ (b | ~d), a, b, x, s, t);
+}
+
+/*
+ * Add integers, wrapping at 2^32. This uses 16-bit operations internally
+ * to work around bugs in some JS interpreters.
+ */
+function safe_add(x, y) {
+  var lsw = (x & 0xffff) + (y & 0xffff);
+  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+  return (msw << 16) | (lsw & 0xffff);
+}
+
+/*
+ * Bitwise rotate a 32-bit number to the left.
+ */
+function bit_rol(num, cnt) {
+  return (num << cnt) | (num >>> (32 - cnt));
+}
+
+export default {
+  md5: function (str) {
+    return hex_md5(str);
+  },
+};

package/package.json

@@ -0,0 +1,90 @@
+{
+  "id": "rexma-design",
+  "name": "rexma-design",
+  "displayName": "rexma-design",
+  "version": "0.0.1",
+  "description": "rexma-design",
+  "keywords": [
+    "rexma-design"
+  ],
+  "repository": "",
+  "engines": {
+    "HBuilderX": "^3.1.0"
+  },
+  "dcloudext": {
+    "type": "component-vue",
+    "sale": {
+      "regular": {
+        "price": "0.00"
+      },
+      "sourcecode": {
+        "price": "0.00"
+      }
+    },
+    "contact": {
+      "qq": ""
+    },
+    "declaration": {
+      "ads": "",
+      "data": "",
+      "permissions": ""
+    },
+    "npmurl": ""
+  },
+  "uni_modules": {
+    "dependencies": [],
+    "encrypt": [],
+    "platforms": {
+      "cloud": {
+        "tcb": "u",
+        "aliyun": "u",
+        "alipay": "u"
+      },
+      "client": {
+        "Vue": {
+          "vue2": "u",
+          "vue3": "u"
+        },
+        "App": {
+          "app-vue": "u",
+          "app-nvue": "u",
+          "app-uvue": "u"
+        },
+        "H5-mobile": {
+          "Safari": "u",
+          "Android Browser": "u",
+          "微信浏览器(Android)": "u",
+          "QQ浏览器(Android)": "u"
+        },
+        "H5-pc": {
+          "Chrome": "u",
+          "IE": "u",
+          "Edge": "u",
+          "Firefox": "u",
+          "Safari": "u"
+        },
+        "小程序": {
+          "微信": "u",
+          "阿里": "u",
+          "百度": "u",
+          "字节跳动": "u",
+          "QQ": "u",
+          "钉钉": "u",
+          "快手": "u",
+          "飞书": "u",
+          "京东": "u"
+        },
+        "快应用": {
+          "华为": "u",
+          "联盟": "u"
+        }
+      }
+    }
+  },
+  "peerDependencies": {
+    "rexma-cli": "*"
+  },
+  "dependencies": {
+    "crypto-js": "^4.2.0"
+  }
+}

package/readme.md

@@ -0,0 +1 @@
+# rexma-design

package/utils/ClientSign.ts

@@ -0,0 +1,69 @@
+import type { IXinhuaClientState } from './XinhuaClient/declaration';
+
+import { enc, mode, AES, pad } from 'crypto-js';
+import xh from './xh';
+
+type IGetClientSignParams = {
+  key: string;
+  offset: string;
+  moduleCode?: string;
+  developmentClientSign?: IXinhuaClientState['clientSign'];
+};
+
+class ClientSign {
+  /**
+   * ASE 解密
+   * @description 使用加密秘钥，对 需要解密的参数 进行解密
+   * @param {string} content - 需要解密的参数
+   * @param {string} params.key - 加密密钥（长度必须是 16 的整数倍）
+   * @param {string} params.offset - 偏移量
+   */
+  static aesDecryptParams(content, { key, offset }) {
+    if (!key || !offset) {
+      throw new Error('缺少加密相关配置');
+    }
+
+    // 密钥 - 从 UTF-8 编码 解析出原始字符串
+    const keyUTF8 = enc.Utf8.parse(key);
+    // 偏移量（在此公司内是固定的） - 从 UTF-8编码 解析出原始字符串
+    const offsetUTF8 = enc.Utf8.parse(offset);
+
+    const bytes = AES.decrypt(content, keyUTF8, {
+      iv: offsetUTF8,
+      mode: mode.CBC,
+      padding: pad.Pkcs7,
+    });
+
+    return bytes.toString(enc.Utf8);
+  }
+
+  /**
+   * D@description 获取客户端签名
+   */
+  static async getClientSign(options: IGetClientSignParams) {
+    const { developmentClientSign, key, offset, moduleCode } = options;
+    // @ts-ignore
+    if (process?.env?.NODE_ENV === 'development' && developmentClientSign) {
+      return developmentClientSign;
+    }
+    if (!xh.isMediaConvergenceXinhuaApp()) {
+      return {
+        sign: '',
+        subDomain: '',
+      };
+    }
+    const clientSignInfo: any = await new Promise((resolve) => {
+      xh.getClientSign({
+        moduleCode,
+        success: (res) => resolve(res),
+      });
+    });
+    return {
+      sign: this.aesDecryptParams(clientSignInfo.cs, { key, offset }),
+      subDomain: clientSignInfo.subDomain,
+      siteId: clientSignInfo.siteId,
+    };
+  }
+}
+
+export default ClientSign;

package/utils/XinhuaClient/declaration.ts

@@ -0,0 +1,25 @@
+export type IXinhuaClientState = {
+  /** 站点 id */
+  siteId: string;
+  /** 用户 id */
+  userId: string;
+  /** 状态栏高度 */
+  statusBarHeight: number;
+  /** 签名信息 */
+  clientSign: {
+    sign: string;
+    subDomain: string;
+  };
+};
+
+/**
+ * @description 初始化方法参数
+ */
+export type IXinhuaClientInitOptions = {
+  clientSign: {
+    key: string;
+    offset: string;
+    moduleCode?: string;
+  };
+  developmentState?: IXinhuaClientState;
+};

package/utils/XinhuaClient/index.ts

@@ -0,0 +1,90 @@
+import type { IXinhuaClientInitOptions, IXinhuaClientState } from './declaration';
+
+import getValueFromUA from '../getValueFromUA';
+import md5Libs from '../../lib/md5';
+import ClientSign from '../ClientSign';
+import xh from '../xh';
+
+class XinhuaClient {
+  /** 数据初始化是否完成 */
+  private static initStatus: boolean = false;
+  /** 站点 id */
+  private static state: IXinhuaClientState = {
+    siteId: '',
+    userId: '',
+    statusBarHeight: 0,
+    clientSign: {
+      sign: '',
+      subDomain: '',
+    },
+  };
+  /** 初始化信息 */
+  private static initOptions: IXinhuaClientInitOptions;
+
+  static init(options: IXinhuaClientInitOptions) {
+    this.initOptions = options;
+  }
+
+  private static async stateInit() {
+    const initOptions = this.initOptions;
+    // @ts-ignore
+    if (process?.env?.NODE_ENV === 'development' && initOptions.developmentState) {
+      this.state = {
+        ...this.state,
+        ...initOptions.developmentState,
+      };
+    }
+    if (xh.isMediaConvergenceXinhuaApp()) {
+      // 客户端环境
+      this.state.siteId = getValueFromUA('currentSiteId');
+      this.state.userId = getValueFromUA('userId');
+      const numberStatusBarHeight = Number(getValueFromUA('statusBarHeight'));
+      this.state.statusBarHeight = isNaN(numberStatusBarHeight) ? 0 : numberStatusBarHeight;
+      this.state.clientSign = await ClientSign.getClientSign({
+        key: initOptions.clientSign.key,
+        offset: initOptions.clientSign.offset,
+        moduleCode: initOptions.clientSign.moduleCode,
+      });
+    }
+    this.initStatus = true;
+  }
+
+  /**
+   * @description 使用数据状态
+   */
+  static async useState() {
+    if (!this.initStatus) {
+      await this.stateInit();
+    }
+    return this.state;
+  }
+
+  /**
+   * @@description 生成签名参数
+   */
+  static async getSignRequestParams(params: Record<string, any>) {
+    if (!this.initStatus) {
+      await this.stateInit();
+    }
+    const requestParams = { ...params },
+      initialState = this.state;
+    if (initialState.userId) {
+      requestParams.userId = initialState.userId;
+    }
+    if (initialState.siteId) {
+      requestParams.siteId = initialState.siteId;
+    }
+    requestParams.currentTimeMillis = new Date().getTime();
+    if (initialState.clientSign && initialState.clientSign.sign) {
+      const paramsArr = Object.values(requestParams);
+      paramsArr.push(initialState.clientSign.sign);
+      paramsArr.sort();
+      requestParams.signature = md5Libs.md5(paramsArr.join(''));
+    }
+    return requestParams;
+  }
+
+  private constructor() {}
+}
+
+export default XinhuaClient;

package/utils/getValueFromUA.ts

@@ -0,0 +1,26 @@
+/**
+ * @description 从 ua 中根据 key 获取信息
+ */
+function getValueFromUA(name: string) {
+  // #ifdef H5
+  const userAgent = window.navigator.userAgent;
+  const userAgentArr = userAgent.split(' ');
+  let uaValue = '';
+  if (userAgentArr) {
+    for (let index in userAgentArr) {
+      const item = userAgentArr[index];
+      if (item.startsWith(name + '/')) {
+        uaValue = item.split('/')[1];
+        break;
+      }
+    }
+  }
+  return uaValue;
+  // #endif
+
+  // #ifndef H5
+  return '';
+  // #endif
+}
+
+export default getValueFromUA;

package/utils/xh.ts

@@ -0,0 +1,7 @@
+import type { XHDeclaration } from 'rexma-cli/lib/declaration/xinhua-sdk';
+
+import xhImport from 'rexma-cli/dist/xinhua-sdk';
+
+const xh = xhImport as XHDeclaration;
+
+export default xh;