vtils/utils/DataPacker.js

一个面向业务的 JavaScript/TypeScript 实用程序库。

import _createForOfIteratorHelperLoose from "@babel/runtime/helpers/esm/createForOfIteratorHelperLoose";
import { isPlainObject, mapValues, range, shuffle } from 'lodash-uni';
import { base64UrlDecode, base64UrlEncode } from "./base64.js";
import { rot13 } from "./rot13.js";
/**
 * 数据打包器。
 */
export var DataPacker = /*#__PURE__*/function () {
  function DataPacker() {}
  DataPacker.encodeIndexes = function encodeIndexes(indexes) {
    return rot13(base64UrlEncode(Math.random().toString(36).slice(2) + "." + indexes.join('.')));
  };
  DataPacker.decodeIndexes = function decodeIndexes(value) {
    return base64UrlDecode(rot13(value)).split('.').slice(1).map(Number);
  }

  /**
   * 打包数据。
   */;
  DataPacker.pack = function pack(rawData) {
    var notArray = !Array.isArray(rawData);
    var rawList = notArray ? [rawData] : rawData;
    var keys = rawList.length ? shuffle(Object.keys(rawList[0])) : [];
    var indexes = shuffle(range(0, keys.length));
    var values = [];
    for (var _iterator = _createForOfIteratorHelperLoose(rawList), _step; !(_step = _iterator()).done;) {
      var rawItem = _step.value;
      var item = [];
      for (var i = 0, len = indexes.length; i < len; i++) {
        item[indexes[i]] = rawItem[keys[i]];
      }
      values.push(item);
    }
    return {
      _k: keys,
      _v: values,
      _s: DataPacker.encodeIndexes(notArray ? [-1].concat(indexes) : indexes)
    };
  }

  /**
   * 返回结果同 `pack()`，不过类型是原数据的类型。
   */;
  DataPacker.packAsRawType = function packAsRawType(rawData) {
    return DataPacker.pack(rawData);
  }

  /**
   * 解包数据。
   */;
  DataPacker.unpack = function unpack(packedData) {
    var rawList = [];
    var indexes = DataPacker.decodeIndexes(packedData._s);
    var notArray = indexes[0] === -1;
    if (notArray) {
      indexes.shift();
    }
    for (var _iterator2 = _createForOfIteratorHelperLoose(packedData._v), _step2; !(_step2 = _iterator2()).done;) {
      var values = _step2.value;
      var item = {};
      for (var i = 0, len = indexes.length; i < len; i++) {
        item[packedData._k[i]] = values[indexes[i]];
      }
      rawList.push(item);
    }
    return notArray ? rawList[0] : rawList;
  }

  /**
   * 如果是打包后的数据，则解包后返回，否则直接返回。如果是对象，则递归尝试解包。
   *
   * @param value 数据
   * @param depth 递归层级，默认：2
   * @returns 返回结果数据
   */;
  DataPacker.unpackIfNeeded = function unpackIfNeeded(value, depth) {
    if (depth === void 0) {
      depth = 2;
    }
    if (isPlainObject(value)) {
      // 兼容 v2 的 StructuredListTransformer 产生的数据
      // https://github.com/fjc0k/vtils/blob/v2/packages/vtils/src/StructuredListTransformer.ts
      if (value.__IS_PACKED_STRUCTURED_LIST__) {
        value._k = value.keys;
        value._v = value.values;
        value._s = value.signature;
        delete value.__IS_PACKED_STRUCTURED_LIST__;
      }
      if (true) {
        if (value._k && value._v && value._s) {
          return DataPacker.unpack(value);
        }
        if (depth > 0) {
          return mapValues(value, function (v) {
            return DataPacker.unpackIfNeeded(v, depth - 1);
          });
        }
      }
    }
    return value;
  };
  return DataPacker;
}();