初始化

康凯

2022-05-20 aa4c235a8ca67ea8b731f90c951a465e92c0a865

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
'use strict';
 
Object.defineProperty(exports, '__esModule', {
  value: true
});
exports.default = void 0;
 
function _util() {
  const data = _interopRequireDefault(require('util'));
 
  _util = function _util() {
    return data;
  };
 
  return data;
}
 
function _prettyFormat() {
  const data = _interopRequireDefault(require('pretty-format'));
 
  _prettyFormat = function _prettyFormat() {
    return data;
  };
 
  return data;
}
 
function _interopRequireDefault(obj) {
  return obj && obj.__esModule ? obj : {default: obj};
}
 
function _slicedToArray(arr, i) {
  return (
    _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest()
  );
}
 
function _nonIterableRest() {
  throw new TypeError('Invalid attempt to destructure non-iterable instance');
}
 
function _iterableToArrayLimit(arr, i) {
  var _arr = [];
  var _n = true;
  var _d = false;
  var _e = undefined;
  try {
    for (
      var _i = arr[Symbol.iterator](), _s;
      !(_n = (_s = _i.next()).done);
      _n = true
    ) {
      _arr.push(_s.value);
      if (i && _arr.length === i) break;
    }
  } catch (err) {
    _d = true;
    _e = err;
  } finally {
    try {
      if (!_n && _i['return'] != null) _i['return']();
    } finally {
      if (_d) throw _e;
    }
  }
  return _arr;
}
 
function _arrayWithHoles(arr) {
  if (Array.isArray(arr)) return arr;
}
 
const SUPPORTED_PLACEHOLDERS = /%[sdifjoOp%]/g;
const PRETTY_PLACEHOLDER = '%p';
const INDEX_PLACEHOLDER = '%#';
const PLACEHOLDER_PREFIX = '%';
const JEST_EACH_PLACEHOLDER_ESCAPE = '@@__JEST_EACH_PLACEHOLDER_ESCAPE__@@';
 
var _default = (title, arrayTable) =>
  normaliseTable(arrayTable).map((row, index) => ({
    arguments: row,
    title: formatTitle(title, row, index)
  }));
 
exports.default = _default;
 
const normaliseTable = table => (isTable(table) ? table : table.map(colToRow));
 
const isTable = table => table.every(Array.isArray);
 
const colToRow = col => [col];
 
const formatTitle = (title, row, rowIndex) =>
  row
    .reduce((formattedTitle, value) => {
      const _getMatchingPlacehold = getMatchingPlaceholders(formattedTitle),
        _getMatchingPlacehold2 = _slicedToArray(_getMatchingPlacehold, 1),
        placeholder = _getMatchingPlacehold2[0];
 
      const normalisedValue = normalisePlaceholderValue(value);
      if (!placeholder) return formattedTitle;
      if (placeholder === PRETTY_PLACEHOLDER)
        return interpolatePrettyPlaceholder(formattedTitle, normalisedValue);
      return _util().default.format(formattedTitle, normalisedValue);
    }, interpolateTitleIndex(title, rowIndex))
    .replace(new RegExp(JEST_EACH_PLACEHOLDER_ESCAPE, 'g'), PLACEHOLDER_PREFIX);
 
const normalisePlaceholderValue = value =>
  typeof value === 'string' && SUPPORTED_PLACEHOLDERS.test(value)
    ? value.replace(PLACEHOLDER_PREFIX, JEST_EACH_PLACEHOLDER_ESCAPE)
    : value;
 
const getMatchingPlaceholders = title =>
  title.match(SUPPORTED_PLACEHOLDERS) || [];
 
const interpolateTitleIndex = (title, index) =>
  title.replace(INDEX_PLACEHOLDER, index.toString());
 
const interpolatePrettyPlaceholder = (title, value) =>
  title.replace(
    PRETTY_PLACEHOLDER,
    (0, _prettyFormat().default)(value, {
      maxDepth: 1,
      min: true
    })
  );