@indfnd/utils 0.0.31

package/src/utils/sm3/sm3.ts

@@ -0,0 +1,238 @@
+/**
+ * 左补0到指定长度
+ */
+function leftPad(input, num) {
+  if (input.length >= num) return input
+
+  return new Array(num - input.length + 1).join('0') + input
+}
+
+/**
+ * 二进制转化为十六进制
+ */
+function binary2hex(binary) {
+  const binaryLength = 8
+  let hex = ''
+  for (let i = 0; i < binary.length / binaryLength; i++) {
+    hex += leftPad(parseInt(binary.substr(i * binaryLength, binaryLength), 2).toString(16), 2)
+  }
+  return hex
+}
+
+/**
+ * 十六进制转化为二进制
+ */
+function hex2binary(hex) {
+  const hexLength = 2
+  let binary = ''
+  for (let i = 0; i < hex.length / hexLength; i++) {
+    binary += leftPad(parseInt(hex.substr(i * hexLength, hexLength), 16).toString(2), 8)
+  }
+  return binary
+}
+
+/**
+ * 普通字符串转化为二进制
+ */
+function str2binary(str) {
+  let binary = ''
+  for (const ch of str) {
+    binary += leftPad(ch.codePointAt(0).toString(2), 8)
+  }
+  return binary
+}
+
+/**
+ * 循环左移
+ */
+function rol(str, n) {
+  return str.substring(n % str.length) + str.substr(0, n % str.length)
+}
+
+/**
+ * 二进制运算
+ */
+function binaryCal(x, y, method) {
+  const a = x || ''
+  const b = y || ''
+  const result = []
+  let prevResult
+
+  for (let i = a.length - 1; i >= 0; i--) {
+    // 大端
+    prevResult = method(a[i], b[i], prevResult)
+    result[i] = prevResult[0]
+  }
+  return result.join('')
+}
+
+/**
+ * 二进制异或运算
+ */
+function xor(x, y) {
+  return binaryCal(x, y, (a, b) => [a === b ? '0' : '1'])
+}
+
+/**
+ * 二进制与运算
+ */
+function and(x, y) {
+  return binaryCal(x, y, (a, b) => [a === '1' && b === '1' ? '1' : '0'])
+}
+
+/**
+ * 二进制或运算
+ */
+function or(x, y) {
+  return binaryCal(x, y, (a, b) => [a === '1' || b === '1' ? '1' : '0']) // a === '0' && b === '0' ? '0' : '1'
+}
+
+/**
+ * 二进制与运算
+ */
+function add(x, y) {
+  const result = binaryCal(x, y, (a, b, prevResult) => {
+    const carry = prevResult ? prevResult[1] : '0' || '0'
+
+    // a,b不等时,carry不变，结果与carry相反
+    // a,b相等时，结果等于原carry，新carry等于a
+    if (a !== b) return [carry === '0' ? '1' : '0', carry]
+
+    return [carry, a]
+  })
+
+  return result
+}
+
+/**
+ * 二进制非运算
+ */
+function not(x) {
+  return binaryCal(x, undefined, (a) => [a === '1' ? '0' : '1'])
+}
+
+function calMulti(method) {
+  return (...arr) => arr.reduce((prev, curr) => method(prev, curr))
+}
+
+/**
+ * 压缩函数中的置换函数 P1(X) = X xor (X <<< 9) xor (X <<< 17)
+ */
+function P0(X) {
+  return calMulti(xor)(X, rol(X, 9), rol(X, 17))
+}
+
+/**
+ * 消息扩展中的置换函数 P1(X) = X xor (X <<< 15) xor (X <<< 23)
+ */
+function P1(X) {
+  return calMulti(xor)(X, rol(X, 15), rol(X, 23))
+}
+
+function FF(X, Y, Z, j) {
+  return j >= 0 && j <= 15 ? calMulti(xor)(X, Y, Z) : calMulti(or)(and(X, Y), and(X, Z), and(Y, Z))
+}
+
+function GG(X, Y, Z, j) {
+  return j >= 0 && j <= 15 ? calMulti(xor)(X, Y, Z) : or(and(X, Y), and(not(X), Z))
+}
+
+function T(j) {
+  return j >= 0 && j <= 15 ? hex2binary('79cc4519') : hex2binary('7a879d8a')
+}
+
+/**
+ * 压缩函数
+ */
+function CF(V, Bi) {
+  // 消息扩展
+  const wordLength = 32
+  const W = []
+  const M = [] // W'
+
+  // 将消息分组B划分为16个字W0， W1，…… ，W15 （字为长度为32的比特串）
+  for (let i = 0; i < 16; i++) {
+    W.push(Bi.substr(i * wordLength, wordLength))
+  }
+
+  // W[j] <- P1(W[j−16] xor W[j−9] xor (W[j−3] <<< 15)) xor (W[j−13] <<< 7) xor W[j−6]
+  for (let j = 16; j < 68; j++) {
+    W.push(
+      calMulti(xor)(
+        P1(calMulti(xor)(W[j - 16], W[j - 9], rol(W[j - 3], 15))),
+        rol(W[j - 13], 7),
+        W[j - 6],
+      ),
+    )
+  }
+
+  // W′[j] = W[j] xor W[j+4]
+  for (let j = 0; j < 64; j++) {
+    M.push(xor(W[j], W[j + 4]))
+  }
+
+  // 压缩
+  const wordRegister = [] // 字寄存器
+  for (let j = 0; j < 8; j++) {
+    wordRegister.push(V.substr(j * wordLength, wordLength))
+  }
+
+  let A = wordRegister[0]
+  let B = wordRegister[1]
+  let C = wordRegister[2]
+  let D = wordRegister[3]
+  let E = wordRegister[4]
+  let F = wordRegister[5]
+  let G = wordRegister[6]
+  let H = wordRegister[7]
+
+  // 中间变量
+  let SS1
+  let SS2
+  let TT1
+  let TT2
+  for (let j = 0; j < 64; j++) {
+    SS1 = rol(calMulti(add)(rol(A, 12), E, rol(T(j), j)), 7)
+    SS2 = xor(SS1, rol(A, 12))
+
+    TT1 = calMulti(add)(FF(A, B, C, j), D, SS2, M[j])
+    TT2 = calMulti(add)(GG(E, F, G, j), H, SS1, W[j])
+
+    D = C
+    C = rol(B, 9)
+    B = A
+    A = TT1
+    H = G
+    G = rol(F, 19)
+    F = E
+    E = P0(TT2)
+  }
+
+  return xor([A, B, C, D, E, F, G, H].join(''), V)
+}
+
+function sm3(str) {
+  const binary = str2binary(str)
+
+  // 填充
+  const len = binary.length
+
+  // k是满足len + 1 + k = 448mod512的最小的非负整数
+  let k = len % 512
+
+  // 如果 448 <= (512 % len) < 512，需要多补充 (len % 448) 比特'0'以满足总比特长度为512的倍数
+  k = k >= 448 ? 512 - (k % 448) - 1 : 448 - k - 1
+
+  const m = `${binary}1${leftPad('', k)}${leftPad(len.toString(2), 64)}`.toString() // k个0
+
+  // 迭代压缩
+  const n = (len + k + 65) / 512
+
+  let V = hex2binary('7380166f4914b2b9172442d7da8a0600a96f30bc163138aae38dee4db0fb0e4e')
+  for (let i = 0; i <= n - 1; i++) {
+    const B = m.substr(512 * i, 512)
+    V = CF(V, B)
+  }
+  return binary2hex(V)
+}
+export default sm3

package/src/utils/storage.ts

@@ -0,0 +1,51 @@
+// ============ SessionStorage ============
+export const getSessionStorage = (key: string) => {
+  const value = sessionStorage.getItem(key)
+  if (value) {
+    try {
+      return JSON.parse(value)
+    } catch (error) {
+      return value
+    }
+  }
+  return value
+}
+
+export const setSessionStorage = (key: string, value: any) => {
+  if (typeof value !== 'string') {
+    value = JSON.stringify(value)
+  }
+  sessionStorage.setItem(key, value)
+}
+
+export const removeSessionStorage = (key: string) => {
+  return sessionStorage.removeItem(key)
+}
+
+export function clearSessionStorage() {
+  sessionStorage.clear()
+}
+
+// ============ LocalStorage ============
+export const getLocalStorage = (key: string) => {
+  const value = localStorage.getItem(key)
+  if (value) {
+    try {
+      return JSON.parse(value)
+    } catch (error) {
+      return value
+    }
+  }
+  return value
+}
+
+export const setLocalStorage = (key: string, value: any) => {
+  if (typeof value !== 'string') {
+    value = JSON.stringify(value)
+  }
+  localStorage.setItem(key, value)
+}
+
+export const removeLocalStorage = (key: string) => {
+  return localStorage.removeItem(key)
+}

package/src/utils/table.ts

@@ -0,0 +1,252 @@
+/*
+ * @Author: huxuetong
+ * @Date: 2023-10-27 15:05:25
+ * @Last Modified by: huxuetong
+ * @Last Modified time: 2024-01-08 22:58:03
+ */
+
+import _ from 'lodash'
+
+const GROUP_SEP = '__'
+const VALUE_SEP = '--'
+
+interface ColumnGroup {
+  // key和title配套使用，用于非动态数据的列分组，如销量、销额等
+  key?: string
+  title?: string
+
+  // keyProp、titleProp、titleFormatter配套使用，用于和动态数据有关的列分组，如工业、卷烟等
+  keyProp?: string
+  titleProp?: string
+  titleFormatter?: (title: string) => string
+
+  // 每层分组表头下继续分组
+  children?: ColumnGroup[]
+  [propName: string]: any
+}
+
+interface row2columnOption {
+  // 组织后表格列定义key对应属性名称
+  keyPropName?: string
+  // 组织后表格列定义title对应属性名称
+  titlePropName?: string
+  // 组织列定义 key 的前缀
+  keyPrefix?: string
+  // 组织列定义 key 的后缀
+  keyLastSuffix?: string
+}
+
+interface Column {
+  key?: string
+  title?: string
+  children?: Column[]
+  [propName: string]: any
+}
+
+interface row2columnResult {
+  columns: Column[]
+  data: Array<any>
+}
+
+// 根据各层分组定义组织出表头
+function renderColumnTree(
+  data: Array<any>,
+  columnGroup: ColumnGroup,
+  option: row2columnOption = {},
+): Column | Column[] {
+  const { key, keyProp, title, titleProp, titleFormatter, children, ...args } = columnGroup
+  const {
+    keyPropName = 'key',
+    titlePropName = 'title',
+    keyPrefix = '',
+    keyLastSuffix = '',
+  } = option
+
+  // 动态列
+  if (keyProp) {
+    const columnGroupData = _.uniqBy(data, columnGroup.keyProp)
+    return columnGroupData.map((item) => {
+      const columnTitle = titleFormatter ? titleFormatter(item[titleProp]) : item[titleProp]
+
+      // 不是最后一层，继续组织tree
+      if (children && children.length) {
+        // 前缀加__ 和下一层做分割
+        const prefix = `${keyPrefix}${keyProp}${VALUE_SEP}${item[keyProp]}${GROUP_SEP}`
+        const columnChildren = children.map((child) => {
+          return renderColumnTree(data, child, { ...option, keyPrefix: prefix })
+        })
+
+        return {
+          ...args,
+          [titlePropName]: columnTitle,
+          children: _.flatten(columnChildren), // 多层动态列下，上面的层级拿到的是个二维数组，flatten一下
+        }
+      }
+
+      // 最后一层 返回key、title
+      const suffix = keyLastSuffix ? `${GROUP_SEP}${keyLastSuffix}` : ''
+      return {
+        ...args,
+        [keyPropName]: `${keyPrefix}${keyProp}${VALUE_SEP}${item[keyProp]}${suffix}`,
+        [titlePropName]: columnTitle,
+      }
+    })
+  }
+
+  // 非动态列 不是最后一层
+  if (children && children.length) {
+    // 非动态列的下一层一般都是在一行数据上的，所以拼接key时不加__做不同层级的分割，而是和下一层一起作为属性名
+    const prefix = `${keyPrefix}${key}`
+    const columnChildren = children.map((child) => {
+      return renderColumnTree(data, child, { ...option, keyPrefix: prefix })
+    })
+
+    return { ...args, [titlePropName]: title, children: _.flatten(columnChildren) }
+  }
+  return { ...args, [keyPropName]: `${keyPrefix}${key}`, [titlePropName]: title }
+}
+
+// 获取最后一层的表头
+function getLeafColumns(columns: Column[] = []): Column[] {
+  if (!columns || !columns.length) return []
+  return columns.reduce((rlt, column) => {
+    if (column.children) {
+      return [...rlt, ...getLeafColumns(column.children)]
+    } else {
+      return [...rlt, column]
+    }
+  }, [] as Column[])
+}
+
+// 组织行转列结果的每一行数据
+function renderRowData(data: Array<any>, keys: string[]) {
+  if (!keys.length) return
+  const key = keys[0]
+  keys = keys.slice(1)
+
+  if (key.includes(VALUE_SEP) && keys.length) {
+    // 这个分组是动态列的分组，且不是最后一层
+    const [keyProp, keyValue] = key.split(VALUE_SEP)
+    // 一层一层往下找，筛选符合该分组的数据
+    const matchData = _.filter(data, { [keyProp]: keyValue })
+    return renderRowData(matchData, keys)
+  }
+
+  if (keys.length) {
+    console.error('怎么会不是最后一层分组呢，请联系开发人员查看！')
+  }
+  // 最后一层，固定指标，赋值
+  const value = data?.[0]?.[key]
+  return value
+}
+
+/**
+ * 行转列公共方法
+ * ! 目前是根据非动态列下全是非动态列的分组来组织的，若动态列和非动态列相互穿插分组，那就糟糕了
+ *
+ * @param data 所有行数据
+ * @param columnGroups 分组定义
+ * @param rowKey 行转列目标结果的行主键
+ * @param option 一些参数
+ * @returns 行转列后的表头和数据
+ */
+export function row2column(
+  data: Array<any> = [],
+  columnGroups: ColumnGroup[] = [],
+  rowKey: string,
+  option: row2columnOption = {},
+): row2columnResult {
+  // 组织表头
+  const columns = _.flatten<Column>(
+    columnGroups.map((group) => renderColumnTree(data, group, option)),
+  )
+  const leafColumns = getLeafColumns(columns)
+
+  // 组织数据
+  const rowKeyUniqData = _.uniqBy(data, rowKey)
+  const groupData = _.groupBy(data, rowKey)
+  const rltData = rowKeyUniqData.map((item) => {
+    const rowGroupData = groupData[item[rowKey]] || []
+    const newItem = { ...item }
+
+    leafColumns.forEach((column) => {
+      const columnKey: string = column[option.keyPropName || 'key']
+      const keys = columnKey.split(GROUP_SEP) || []
+      const value = renderRowData(rowGroupData, keys)
+      newItem[columnKey] = value
+      // 去掉原始数据的字段
+      delete newItem[keys[keys.length - 1]]
+    })
+    return newItem
+  })
+
+  return { data: rltData, columns }
+}
+
+// -----------------------------------------------------------------------------
+
+// 将每一行转回行数据
+function flattenRowData(
+  rowData = {},
+  leafColumns: Column[] = [],
+  option: row2columnOption = {},
+): Array<any> {
+  const rlt = []
+  // 取出所有非动态列
+  const newItem = {}
+  const keys = Object.keys(rowData)
+  keys.forEach((key) => {
+    if (!key.includes(GROUP_SEP)) {
+      newItem[key] = rowData[key]
+    }
+  })
+
+  leafColumns.forEach((column) => {
+    const cellData = {}
+    const columnKey: string = column[option.keyPropName || 'key']
+
+    if (columnKey.includes(GROUP_SEP)) {
+      // 动态列
+      const keys = columnKey.split(GROUP_SEP)
+      keys.forEach((key, idx) => {
+        if (key.includes(VALUE_SEP) && keys.length) {
+          // 这个分组是动态列的分组，且不是最后一层
+          const [keyProp, keyValue] = key.split(VALUE_SEP)
+          cellData[keyProp] = keyValue
+        } else if (keys.length !== idx + 1) {
+          console.error('columns有问题，请检查！')
+        } else {
+          // 如果结果集里有该分组对应的数据，在其中加上这个列对应的指标数据，如果没有，增加一条该分组的数据
+          const item = _.find(rlt, cellData)
+          if (!item) {
+            rlt.push({ ...newItem, ...cellData, [key]: rowData[columnKey] })
+          } else {
+            item[key] = rowData[columnKey]
+          }
+        }
+      })
+    }
+  })
+
+  return rlt
+}
+
+/**
+ * 从行转列的数据转回行数据
+ *
+ * @param data 行转列后数据
+ * @param columns 行转列后的列定义
+ * @param option 一些参数
+ * @returns 行数据
+ */
+export function flattenRow2ColumnData(
+  data: Array<any> = [],
+  columns: Column[] = [],
+  option: row2columnOption = {},
+): Array<any> {
+  const leafColumns = getLeafColumns(columns)
+  return data.reduce(
+    (rlt, rowData) => [...rlt, ...flattenRowData(rowData, leafColumns, option)],
+    [],
+  )
+}

package/src/utils/token.ts

@@ -0,0 +1,57 @@
+import { getLocalStorage, getSessionStorage, setLocalStorage } from './storage'
+
+const TOKEN_KEY = 'v8-token'
+
+const TOKEN_KEY_IBP = 'lambo-token'
+
+// 要从门户跳转过来，sessionStorage不能带token过来，改成localStorage
+export function setToken(token: string) {
+  setLocalStorage(TOKEN_KEY, token)
+  Cookie.set('TOKEN_KEY', token, 1)
+}
+
+export function getToken(): string | boolean {
+  let token = getSessionStorage(TOKEN_KEY_IBP)
+  if (!token) {
+    token = Cookie.get('lambo-sso-key')
+  }
+  if (!token) {
+    token = Cookie.get('TOKEN_KEY')
+  }
+  if (!token) {
+    token = getLocalStorage(TOKEN_KEY)
+  }
+  return token || false
+}
+
+const Cookie = {
+  set: function (key: string, value: string, exdays: number) {
+    //校验Key, key中不能有等号【=】
+    if (key.indexOf('=') !== -1) {
+      throw new Error('Cookie不支持key中使用等号【=】, key:' + key)
+    }
+    let exdate = new Date() // 获取时间
+    exdate.setTime(exdate.getTime() + 24 * 60 * 60 * 1000 * exdays) // 保存的天数
+    // 字符串拼接cookie
+    // eslint-disable-next-line camelcase
+    window.document.cookie = key + '=' + value + ';path=/;expires=' + exdate.toGMTString()
+  },
+
+  get: function (key: string) {
+    if (document.cookie.length > 0) {
+      // 这里显示的格式需要切割一下自己可输出看下
+      var arr = document.cookie.split('; ')
+      for (let i = 0; i < arr.length; i++) {
+        let arr2 = arr[i].split('=') // 再次切割
+        // 判断查找相对应的值
+        if (arr2[0] === key) {
+          var value = arr2[1]
+          for (let j = 2; j < arr2.length; j++) {
+            value += '=' + arr2[j]
+          }
+          return value
+        }
+      }
+    }
+  },
+}

package/src/utils/uuid.ts

@@ -0,0 +1,10 @@
+/**
+ * 生成uid
+ */
+export function guid() {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+    var r = (Math.random() * 16) | 0,
+      v = c === 'x' ? r : (r & 0x3) | 0x8
+    return v.toString(16)
+  })
+}