优化

‘liusuyi’

2023-10-21 ae92b6823499cfab77201b4033922fa373fb37a3

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
'use strict';
 
const inherits = require('inherits');
 
function Reporter(options) {
  this._reporterState = {
    obj: null,
    path: [],
    options: options || {},
    errors: []
  };
}
exports.Reporter = Reporter;
 
Reporter.prototype.isError = function isError(obj) {
  return obj instanceof ReporterError;
};
 
Reporter.prototype.save = function save() {
  const state = this._reporterState;
 
  return { obj: state.obj, pathLen: state.path.length };
};
 
Reporter.prototype.restore = function restore(data) {
  const state = this._reporterState;
 
  state.obj = data.obj;
  state.path = state.path.slice(0, data.pathLen);
};
 
Reporter.prototype.enterKey = function enterKey(key) {
  return this._reporterState.path.push(key);
};
 
Reporter.prototype.exitKey = function exitKey(index) {
  const state = this._reporterState;
 
  state.path = state.path.slice(0, index - 1);
};
 
Reporter.prototype.leaveKey = function leaveKey(index, key, value) {
  const state = this._reporterState;
 
  this.exitKey(index);
  if (state.obj !== null)
    state.obj[key] = value;
};
 
Reporter.prototype.path = function path() {
  return this._reporterState.path.join('/');
};
 
Reporter.prototype.enterObject = function enterObject() {
  const state = this._reporterState;
 
  const prev = state.obj;
  state.obj = {};
  return prev;
};
 
Reporter.prototype.leaveObject = function leaveObject(prev) {
  const state = this._reporterState;
 
  const now = state.obj;
  state.obj = prev;
  return now;
};
 
Reporter.prototype.error = function error(msg) {
  let err;
  const state = this._reporterState;
 
  const inherited = msg instanceof ReporterError;
  if (inherited) {
    err = msg;
  } else {
    err = new ReporterError(state.path.map(function(elem) {
      return '[' + JSON.stringify(elem) + ']';
    }).join(''), msg.message || msg, msg.stack);
  }
 
  if (!state.options.partial)
    throw err;
 
  if (!inherited)
    state.errors.push(err);
 
  return err;
};
 
Reporter.prototype.wrapResult = function wrapResult(result) {
  const state = this._reporterState;
  if (!state.options.partial)
    return result;
 
  return {
    result: this.isError(result) ? null : result,
    errors: state.errors
  };
};
 
function ReporterError(path, msg) {
  this.path = path;
  this.rethrow(msg);
}
inherits(ReporterError, Error);
 
ReporterError.prototype.rethrow = function rethrow(msg) {
  this.message = msg + ' at: ' + (this.path || '(shallow)');
  if (Error.captureStackTrace)
    Error.captureStackTrace(this, ReporterError);
 
  if (!this.stack) {
    try {
      // IE only adds stack when thrown
      throw new Error(this.message);
    } catch (e) {
      this.stack = e.stack;
    }
  }
  return this;
};