rest-client-sdk 7.2.3 → 7.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.cjs CHANGED
@@ -1,853 +1,603 @@
1
1
  (function (global, factory) {
2
2
  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('urijs'), require('deep-diff')) :
3
3
  typeof define === 'function' && define.amd ? define(['exports', 'urijs', 'deep-diff'], factory) :
4
- (global = global || self, factory(global['rest-client-sdk'] = {}, global.URI, global.diff));
5
- }(this, (function (exports, URI, diff) { 'use strict';
4
+ (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["rest-client-sdk"] = {}, global.URI, global.diff));
5
+ })(this, (function (exports, URI, diff) { 'use strict';
6
6
 
7
- URI = URI && Object.prototype.hasOwnProperty.call(URI, 'default') ? URI['default'] : URI;
8
- diff = diff && Object.prototype.hasOwnProperty.call(diff, 'default') ? diff['default'] : diff;
9
-
10
- function _typeof(obj) {
11
- "@babel/helpers - typeof";
12
-
13
- if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
14
- _typeof = function (obj) {
15
- return typeof obj;
16
- };
17
- } else {
18
- _typeof = function (obj) {
19
- return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
20
- };
21
- }
22
-
23
- return _typeof(obj);
24
- }
25
-
26
- function _classCallCheck(instance, Constructor) {
27
- if (!(instance instanceof Constructor)) {
28
- throw new TypeError("Cannot call a class as a function");
29
- }
30
- }
31
-
32
- function _defineProperties(target, props) {
33
- for (var i = 0; i < props.length; i++) {
34
- var descriptor = props[i];
35
- descriptor.enumerable = descriptor.enumerable || false;
36
- descriptor.configurable = true;
37
- if ("value" in descriptor) descriptor.writable = true;
38
- Object.defineProperty(target, descriptor.key, descriptor);
39
- }
40
- }
41
-
42
- function _createClass(Constructor, protoProps, staticProps) {
43
- if (protoProps) _defineProperties(Constructor.prototype, protoProps);
44
- if (staticProps) _defineProperties(Constructor, staticProps);
45
- return Constructor;
46
- }
47
-
48
- function _defineProperty(obj, key, value) {
49
- if (key in obj) {
50
- Object.defineProperty(obj, key, {
51
- value: value,
52
- enumerable: true,
53
- configurable: true,
54
- writable: true
55
- });
56
- } else {
57
- obj[key] = value;
58
- }
59
-
60
- return obj;
61
- }
62
-
63
- function ownKeys(object, enumerableOnly) {
64
- var keys = Object.keys(object);
65
-
66
- if (Object.getOwnPropertySymbols) {
67
- var symbols = Object.getOwnPropertySymbols(object);
68
- if (enumerableOnly) symbols = symbols.filter(function (sym) {
69
- return Object.getOwnPropertyDescriptor(object, sym).enumerable;
70
- });
71
- keys.push.apply(keys, symbols);
72
- }
73
-
74
- return keys;
75
- }
76
-
77
- function _objectSpread2(target) {
78
- for (var i = 1; i < arguments.length; i++) {
79
- var source = arguments[i] != null ? arguments[i] : {};
80
-
81
- if (i % 2) {
82
- ownKeys(Object(source), true).forEach(function (key) {
83
- _defineProperty(target, key, source[key]);
84
- });
85
- } else if (Object.getOwnPropertyDescriptors) {
86
- Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
87
- } else {
88
- ownKeys(Object(source)).forEach(function (key) {
89
- Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
90
- });
91
- }
92
- }
93
-
94
- return target;
95
- }
96
-
97
- function _inherits(subClass, superClass) {
98
- if (typeof superClass !== "function" && superClass !== null) {
99
- throw new TypeError("Super expression must either be null or a function");
100
- }
101
-
102
- subClass.prototype = Object.create(superClass && superClass.prototype, {
103
- constructor: {
104
- value: subClass,
105
- writable: true,
106
- configurable: true
107
- }
108
- });
109
- if (superClass) _setPrototypeOf(subClass, superClass);
7
+ function _arrayLikeToArray(r, a) {
8
+ (null == a || a > r.length) && (a = r.length);
9
+ for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
10
+ return n;
110
11
  }
111
-
112
- function _getPrototypeOf(o) {
113
- _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
114
- return o.__proto__ || Object.getPrototypeOf(o);
115
- };
116
- return _getPrototypeOf(o);
12
+ function _assertClassBrand(e, t, n) {
13
+ if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
14
+ throw new TypeError("Private element is not present on this object");
117
15
  }
118
-
119
- function _setPrototypeOf(o, p) {
120
- _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
121
- o.__proto__ = p;
122
- return o;
123
- };
124
-
125
- return _setPrototypeOf(o, p);
16
+ function _assertThisInitialized(e) {
17
+ if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
18
+ return e;
126
19
  }
127
-
128
- function _isNativeReflectConstruct() {
129
- if (typeof Reflect === "undefined" || !Reflect.construct) return false;
130
- if (Reflect.construct.sham) return false;
131
- if (typeof Proxy === "function") return true;
132
-
133
- try {
134
- Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
135
- return true;
136
- } catch (e) {
137
- return false;
138
- }
20
+ function _callSuper(t, o, e) {
21
+ return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e));
139
22
  }
140
-
141
- function _construct(Parent, args, Class) {
142
- if (_isNativeReflectConstruct()) {
143
- _construct = Reflect.construct;
144
- } else {
145
- _construct = function _construct(Parent, args, Class) {
146
- var a = [null];
147
- a.push.apply(a, args);
148
- var Constructor = Function.bind.apply(Parent, a);
149
- var instance = new Constructor();
150
- if (Class) _setPrototypeOf(instance, Class.prototype);
151
- return instance;
152
- };
153
- }
154
-
155
- return _construct.apply(null, arguments);
23
+ function _checkPrivateRedeclaration(e, t) {
24
+ if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
156
25
  }
157
-
158
- function _isNativeFunction(fn) {
159
- return Function.toString.call(fn).indexOf("[native code]") !== -1;
26
+ function _classCallCheck(a, n) {
27
+ if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
160
28
  }
161
-
162
- function _wrapNativeSuper(Class) {
163
- var _cache = typeof Map === "function" ? new Map() : undefined;
164
-
165
- _wrapNativeSuper = function _wrapNativeSuper(Class) {
166
- if (Class === null || !_isNativeFunction(Class)) return Class;
167
-
168
- if (typeof Class !== "function") {
169
- throw new TypeError("Super expression must either be null or a function");
170
- }
171
-
172
- if (typeof _cache !== "undefined") {
173
- if (_cache.has(Class)) return _cache.get(Class);
174
-
175
- _cache.set(Class, Wrapper);
176
- }
177
-
178
- function Wrapper() {
179
- return _construct(Class, arguments, _getPrototypeOf(this).constructor);
180
- }
181
-
182
- Wrapper.prototype = Object.create(Class.prototype, {
183
- constructor: {
184
- value: Wrapper,
185
- enumerable: false,
186
- writable: true,
187
- configurable: true
188
- }
189
- });
190
- return _setPrototypeOf(Wrapper, Class);
191
- };
192
-
193
- return _wrapNativeSuper(Class);
29
+ function _classPrivateFieldGet2(s, a) {
30
+ return s.get(_assertClassBrand(s, a));
194
31
  }
195
-
196
- function _objectWithoutPropertiesLoose(source, excluded) {
197
- if (source == null) return {};
198
- var target = {};
199
- var sourceKeys = Object.keys(source);
200
- var key, i;
201
-
202
- for (i = 0; i < sourceKeys.length; i++) {
203
- key = sourceKeys[i];
204
- if (excluded.indexOf(key) >= 0) continue;
205
- target[key] = source[key];
206
- }
207
-
208
- return target;
32
+ function _classPrivateFieldInitSpec(e, t, a) {
33
+ _checkPrivateRedeclaration(e, t), t.set(e, a);
209
34
  }
210
-
211
- function _objectWithoutProperties(source, excluded) {
212
- if (source == null) return {};
213
-
214
- var target = _objectWithoutPropertiesLoose(source, excluded);
215
-
216
- var key, i;
217
-
218
- if (Object.getOwnPropertySymbols) {
219
- var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
220
-
221
- for (i = 0; i < sourceSymbolKeys.length; i++) {
222
- key = sourceSymbolKeys[i];
223
- if (excluded.indexOf(key) >= 0) continue;
224
- if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
225
- target[key] = source[key];
226
- }
227
- }
228
-
229
- return target;
35
+ function _classPrivateFieldSet2(s, a, r) {
36
+ return s.set(_assertClassBrand(s, a), r), r;
230
37
  }
231
-
232
- function _assertThisInitialized(self) {
233
- if (self === void 0) {
234
- throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
235
- }
236
-
237
- return self;
38
+ function _construct(t, e, r) {
39
+ if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments);
40
+ var o = [null];
41
+ o.push.apply(o, e);
42
+ var p = new (t.bind.apply(t, o))();
43
+ return r && _setPrototypeOf(p, r.prototype), p;
238
44
  }
239
-
240
- function _possibleConstructorReturn(self, call) {
241
- if (call && (typeof call === "object" || typeof call === "function")) {
242
- return call;
45
+ function _defineProperties(e, r) {
46
+ for (var t = 0; t < r.length; t++) {
47
+ var o = r[t];
48
+ o.enumerable = o.enumerable || false, o.configurable = true, "value" in o && (o.writable = true), Object.defineProperty(e, _toPropertyKey(o.key), o);
243
49
  }
244
-
245
- return _assertThisInitialized(self);
246
- }
247
-
248
- function _createSuper(Derived) {
249
- var hasNativeReflectConstruct = _isNativeReflectConstruct();
250
-
251
- return function _createSuperInternal() {
252
- var Super = _getPrototypeOf(Derived),
253
- result;
254
-
255
- if (hasNativeReflectConstruct) {
256
- var NewTarget = _getPrototypeOf(this).constructor;
257
-
258
- result = Reflect.construct(Super, arguments, NewTarget);
259
- } else {
260
- result = Super.apply(this, arguments);
261
- }
262
-
263
- return _possibleConstructorReturn(this, result);
264
- };
265
50
  }
266
-
267
- function _unsupportedIterableToArray(o, minLen) {
268
- if (!o) return;
269
- if (typeof o === "string") return _arrayLikeToArray(o, minLen);
270
- var n = Object.prototype.toString.call(o).slice(8, -1);
271
- if (n === "Object" && o.constructor) n = o.constructor.name;
272
- if (n === "Map" || n === "Set") return Array.from(o);
273
- if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
274
- }
275
-
276
- function _arrayLikeToArray(arr, len) {
277
- if (len == null || len > arr.length) len = arr.length;
278
-
279
- for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
280
-
281
- return arr2;
51
+ function _createClass(e, r, t) {
52
+ return r && _defineProperties(e.prototype, r), Object.defineProperty(e, "prototype", {
53
+ writable: false
54
+ }), e;
282
55
  }
283
-
284
- function _createForOfIteratorHelper(o, allowArrayLike) {
285
- var it;
286
-
287
- if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
288
- if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
289
- if (it) o = it;
290
- var i = 0;
291
-
292
- var F = function () {};
293
-
56
+ function _createForOfIteratorHelper(r, e) {
57
+ var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
58
+ if (!t) {
59
+ if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e) {
60
+ t && (r = t);
61
+ var n = 0,
62
+ F = function () {};
294
63
  return {
295
64
  s: F,
296
65
  n: function () {
297
- if (i >= o.length) return {
66
+ return n >= r.length ? {
298
67
  done: true
299
- };
300
- return {
68
+ } : {
301
69
  done: false,
302
- value: o[i++]
70
+ value: r[n++]
303
71
  };
304
72
  },
305
- e: function (e) {
306
- throw e;
73
+ e: function (r) {
74
+ throw r;
307
75
  },
308
76
  f: F
309
77
  };
310
78
  }
311
-
312
79
  throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
313
80
  }
314
-
315
- var normalCompletion = true,
316
- didErr = false,
317
- err;
81
+ var o,
82
+ a = true,
83
+ u = false;
318
84
  return {
319
85
  s: function () {
320
- it = o[Symbol.iterator]();
86
+ t = t.call(r);
321
87
  },
322
88
  n: function () {
323
- var step = it.next();
324
- normalCompletion = step.done;
325
- return step;
89
+ var r = t.next();
90
+ return a = r.done, r;
326
91
  },
327
- e: function (e) {
328
- didErr = true;
329
- err = e;
92
+ e: function (r) {
93
+ u = true, o = r;
330
94
  },
331
95
  f: function () {
332
96
  try {
333
- if (!normalCompletion && it.return != null) it.return();
97
+ a || null == t.return || t.return();
334
98
  } finally {
335
- if (didErr) throw err;
99
+ if (u) throw o;
336
100
  }
337
101
  }
338
102
  };
339
103
  }
340
-
341
- function _classPrivateFieldGet(receiver, privateMap) {
342
- var descriptor = privateMap.get(receiver);
343
-
344
- if (!descriptor) {
345
- throw new TypeError("attempted to get private field on non-instance");
104
+ function _defineProperty(e, r, t) {
105
+ return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
106
+ value: t,
107
+ enumerable: true,
108
+ configurable: true,
109
+ writable: true
110
+ }) : e[r] = t, e;
111
+ }
112
+ function _getPrototypeOf(t) {
113
+ return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) {
114
+ return t.__proto__ || Object.getPrototypeOf(t);
115
+ }, _getPrototypeOf(t);
116
+ }
117
+ function _inherits(t, e) {
118
+ if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function");
119
+ t.prototype = Object.create(e && e.prototype, {
120
+ constructor: {
121
+ value: t,
122
+ writable: true,
123
+ configurable: true
124
+ }
125
+ }), Object.defineProperty(t, "prototype", {
126
+ writable: false
127
+ }), e && _setPrototypeOf(t, e);
128
+ }
129
+ function _isNativeFunction(t) {
130
+ try {
131
+ return -1 !== Function.toString.call(t).indexOf("[native code]");
132
+ } catch (n) {
133
+ return "function" == typeof t;
346
134
  }
347
-
348
- if (descriptor.get) {
349
- return descriptor.get.call(receiver);
135
+ }
136
+ function _isNativeReflectConstruct() {
137
+ try {
138
+ var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
139
+ } catch (t) {}
140
+ return (_isNativeReflectConstruct = function () {
141
+ return !!t;
142
+ })();
143
+ }
144
+ function ownKeys(e, r) {
145
+ var t = Object.keys(e);
146
+ if (Object.getOwnPropertySymbols) {
147
+ var o = Object.getOwnPropertySymbols(e);
148
+ r && (o = o.filter(function (r) {
149
+ return Object.getOwnPropertyDescriptor(e, r).enumerable;
150
+ })), t.push.apply(t, o);
350
151
  }
351
-
352
- return descriptor.value;
152
+ return t;
353
153
  }
354
-
355
- function _classPrivateFieldSet(receiver, privateMap, value) {
356
- var descriptor = privateMap.get(receiver);
357
-
358
- if (!descriptor) {
359
- throw new TypeError("attempted to set private field on non-instance");
154
+ function _objectSpread2(e) {
155
+ for (var r = 1; r < arguments.length; r++) {
156
+ var t = null != arguments[r] ? arguments[r] : {};
157
+ r % 2 ? ownKeys(Object(t), true).forEach(function (r) {
158
+ _defineProperty(e, r, t[r]);
159
+ }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
160
+ Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
161
+ });
360
162
  }
361
-
362
- if (descriptor.set) {
363
- descriptor.set.call(receiver, value);
364
- } else {
365
- if (!descriptor.writable) {
366
- throw new TypeError("attempted to set read only private field");
367
- }
368
-
369
- descriptor.value = value;
163
+ return e;
164
+ }
165
+ function _objectWithoutProperties(e, t) {
166
+ if (null == e) return {};
167
+ var o,
168
+ r,
169
+ i = _objectWithoutPropertiesLoose(e, t);
170
+ if (Object.getOwnPropertySymbols) {
171
+ var n = Object.getOwnPropertySymbols(e);
172
+ for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
370
173
  }
371
-
372
- return value;
174
+ return i;
175
+ }
176
+ function _objectWithoutPropertiesLoose(r, e) {
177
+ if (null == r) return {};
178
+ var t = {};
179
+ for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
180
+ if (-1 !== e.indexOf(n)) continue;
181
+ t[n] = r[n];
182
+ }
183
+ return t;
184
+ }
185
+ function _possibleConstructorReturn(t, e) {
186
+ if (e && ("object" == typeof e || "function" == typeof e)) return e;
187
+ if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined");
188
+ return _assertThisInitialized(t);
189
+ }
190
+ function _setPrototypeOf(t, e) {
191
+ return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
192
+ return t.__proto__ = e, t;
193
+ }, _setPrototypeOf(t, e);
373
194
  }
195
+ function _toPrimitive(t, r) {
196
+ if ("object" != typeof t || !t) return t;
197
+ var e = t[Symbol.toPrimitive];
198
+ if (void 0 !== e) {
199
+ var i = e.call(t, r);
200
+ if ("object" != typeof i) return i;
201
+ throw new TypeError("@@toPrimitive must return a primitive value.");
202
+ }
203
+ return ("string" === r ? String : Number)(t);
204
+ }
205
+ function _toPropertyKey(t) {
206
+ var i = _toPrimitive(t, "string");
207
+ return "symbol" == typeof i ? i : i + "";
208
+ }
209
+ function _typeof(o) {
210
+ "@babel/helpers - typeof";
374
211
 
375
- /* eslint-disable max-classes-per-file, no-use-before-define */
212
+ return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
213
+ return typeof o;
214
+ } : function (o) {
215
+ return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
216
+ }, _typeof(o);
217
+ }
218
+ function _unsupportedIterableToArray(r, a) {
219
+ if (r) {
220
+ if ("string" == typeof r) return _arrayLikeToArray(r, a);
221
+ var t = {}.toString.call(r).slice(8, -1);
222
+ return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
223
+ }
224
+ }
225
+ function _wrapNativeSuper(t) {
226
+ var r = "function" == typeof Map ? new Map() : void 0;
227
+ return _wrapNativeSuper = function (t) {
228
+ if (null === t || !_isNativeFunction(t)) return t;
229
+ if ("function" != typeof t) throw new TypeError("Super expression must either be null or a function");
230
+ if (void 0 !== r) {
231
+ if (r.has(t)) return r.get(t);
232
+ r.set(t, Wrapper);
233
+ }
234
+ function Wrapper() {
235
+ return _construct(t, arguments, _getPrototypeOf(this).constructor);
236
+ }
237
+ return Wrapper.prototype = Object.create(t.prototype, {
238
+ constructor: {
239
+ value: Wrapper,
240
+ enumerable: false,
241
+ writable: true,
242
+ configurable: true
243
+ }
244
+ }), _setPrototypeOf(Wrapper, t);
245
+ }, _wrapNativeSuper(t);
246
+ }
376
247
 
377
248
  /**
378
249
  * It's a bit tricky to extends native errors
379
250
  * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error
380
251
  */
381
252
  var HttpError = /*#__PURE__*/function (_Error) {
382
- _inherits(HttpError, _Error);
383
-
384
- var _super = _createSuper(HttpError);
385
-
386
253
  function HttpError(message, baseResponse) {
387
254
  var _this;
388
-
389
255
  _classCallCheck(this, HttpError);
256
+ _this = _callSuper(this, HttpError, [message || 'Http errort']);
390
257
 
391
- _this = _super.call(this, message || 'Http errort'); // Set the prototype explicitly.
392
-
393
- _defineProperty(_assertThisInitialized(_this), "baseResponse", void 0);
394
-
395
- Object.setPrototypeOf(_assertThisInitialized(_this), OauthError.prototype); // Maintains proper stack trace for where our error was thrown (only available on V8)
258
+ // Set the prototype explicitly.
259
+ _defineProperty(_this, "baseResponse", void 0);
260
+ Object.setPrototypeOf(_this, OauthError.prototype);
396
261
 
262
+ // Maintains proper stack trace for where our error was thrown (only available on V8)
397
263
  if (Error.captureStackTrace) {
398
- Error.captureStackTrace(_assertThisInitialized(_this), OauthError);
264
+ Error.captureStackTrace(_this, OauthError);
399
265
  }
400
-
401
266
  _this.name = 'HttpError';
402
267
  _this.baseResponse = baseResponse;
403
268
  return _this;
404
269
  }
270
+
405
271
  /**
406
272
  * Get the JSON of the baseResponse directly, if possible
407
273
  */
408
-
409
-
410
- _createClass(HttpError, [{
274
+ _inherits(HttpError, _Error);
275
+ return _createClass(HttpError, [{
411
276
  key: "responseJson",
412
277
  value: function responseJson() {
413
278
  return this.baseResponse.json();
414
279
  }
415
280
  }]);
416
-
417
- return HttpError;
418
- }( /*#__PURE__*/_wrapNativeSuper(Error));
419
-
281
+ }(/*#__PURE__*/_wrapNativeSuper(Error));
420
282
  var OauthError = /*#__PURE__*/function (_Error2) {
421
- _inherits(OauthError, _Error2);
422
-
423
- var _super2 = _createSuper(OauthError);
424
-
425
283
  function OauthError(message, previousError) {
426
284
  var _this2;
427
-
428
285
  _classCallCheck(this, OauthError);
286
+ _this2 = _callSuper(this, OauthError, [message || 'Oauth error']);
429
287
 
430
- _this2 = _super2.call(this, message || 'Oauth error'); // Set the prototype explicitly.
431
-
432
- _defineProperty(_assertThisInitialized(_this2), "previousError", void 0);
433
-
434
- Object.setPrototypeOf(_assertThisInitialized(_this2), OauthError.prototype); // Maintains proper stack trace for where our error was thrown (only available on V8)
288
+ // Set the prototype explicitly.
289
+ _defineProperty(_this2, "previousError", void 0);
290
+ Object.setPrototypeOf(_this2, OauthError.prototype);
435
291
 
292
+ // Maintains proper stack trace for where our error was thrown (only available on V8)
436
293
  if (Error.captureStackTrace) {
437
- Error.captureStackTrace(_assertThisInitialized(_this2), OauthError);
294
+ Error.captureStackTrace(_this2, OauthError);
438
295
  }
439
-
440
296
  _this2.name = 'OauthError';
441
297
  _this2.previousError = previousError;
442
298
  return _this2;
443
299
  }
444
-
445
- return OauthError;
446
- }( /*#__PURE__*/_wrapNativeSuper(Error));
447
-
448
- var InvalidGrantError = /*#__PURE__*/function (_OauthError) {
449
- _inherits(InvalidGrantError, _OauthError);
450
-
451
- var _super3 = _createSuper(InvalidGrantError);
452
-
300
+ _inherits(OauthError, _Error2);
301
+ return _createClass(OauthError);
302
+ }(/*#__PURE__*/_wrapNativeSuper(Error));
303
+ var InvalidGrantError = /*#__PURE__*/function (_OauthError2) {
453
304
  function InvalidGrantError(message, previousError) {
454
305
  var _this3;
455
-
456
306
  _classCallCheck(this, InvalidGrantError);
307
+ _this3 = _callSuper(this, InvalidGrantError, [message || 'Invalid grant error', previousError]);
457
308
 
458
- _this3 = _super3.call(this, message || 'Invalid grant error', previousError); // Set the prototype explicitly.
459
-
460
- _defineProperty(_assertThisInitialized(_this3), "previousError", void 0);
461
-
462
- Object.setPrototypeOf(_assertThisInitialized(_this3), InvalidGrantError.prototype); // Maintains proper stack trace for where our error was thrown (only available on V8)
309
+ // Set the prototype explicitly.
310
+ _defineProperty(_this3, "previousError", void 0);
311
+ Object.setPrototypeOf(_this3, InvalidGrantError.prototype);
463
312
 
313
+ // Maintains proper stack trace for where our error was thrown (only available on V8)
464
314
  if (Error.captureStackTrace) {
465
- Error.captureStackTrace(_assertThisInitialized(_this3), InvalidGrantError);
315
+ Error.captureStackTrace(_this3, InvalidGrantError);
466
316
  }
467
-
468
317
  _this3.name = 'InvalidGrantError';
469
318
  _this3.previousError = previousError;
470
319
  return _this3;
471
320
  }
472
-
473
- return InvalidGrantError;
321
+ _inherits(InvalidGrantError, _OauthError2);
322
+ return _createClass(InvalidGrantError);
474
323
  }(OauthError);
475
-
476
- var InvalidScopeError = /*#__PURE__*/function (_OauthError2) {
477
- _inherits(InvalidScopeError, _OauthError2);
478
-
479
- var _super4 = _createSuper(InvalidScopeError);
480
-
324
+ var InvalidScopeError = /*#__PURE__*/function (_OauthError3) {
481
325
  function InvalidScopeError(message, previousError) {
482
326
  var _this4;
483
-
484
327
  _classCallCheck(this, InvalidScopeError);
328
+ _this4 = _callSuper(this, InvalidScopeError, [message || 'Invalid scope error', previousError]);
485
329
 
486
- _this4 = _super4.call(this, message || 'Invalid scope error', previousError); // Set the prototype explicitly.
487
-
488
- _defineProperty(_assertThisInitialized(_this4), "previousError", void 0);
489
-
490
- Object.setPrototypeOf(_assertThisInitialized(_this4), InvalidScopeError.prototype); // Maintains proper stack trace for where our error was thrown (only available on V8)
330
+ // Set the prototype explicitly.
331
+ _defineProperty(_this4, "previousError", void 0);
332
+ Object.setPrototypeOf(_this4, InvalidScopeError.prototype);
491
333
 
334
+ // Maintains proper stack trace for where our error was thrown (only available on V8)
492
335
  if (Error.captureStackTrace) {
493
- Error.captureStackTrace(_assertThisInitialized(_this4), InvalidScopeError);
336
+ Error.captureStackTrace(_this4, InvalidScopeError);
494
337
  }
495
-
496
338
  _this4.name = 'InvalidScopeError';
497
339
  _this4.previousError = previousError;
498
340
  return _this4;
499
341
  }
500
-
501
- return InvalidScopeError;
342
+ _inherits(InvalidScopeError, _OauthError3);
343
+ return _createClass(InvalidScopeError);
502
344
  }(OauthError); // 400
503
-
504
-
505
- var BadRequestError = /*#__PURE__*/function (_HttpError) {
506
- _inherits(BadRequestError, _HttpError);
507
-
508
- var _super5 = _createSuper(BadRequestError);
509
-
345
+ var BadRequestError = /*#__PURE__*/function (_HttpError2) {
510
346
  function BadRequestError(message, baseResponse) {
511
347
  var _this5;
512
-
513
348
  _classCallCheck(this, BadRequestError);
349
+ _this5 = _callSuper(this, BadRequestError, [message || 'Bad request', baseResponse]);
514
350
 
515
- _this5 = _super5.call(this, message || 'Bad request', baseResponse); // Set the prototype explicitly.
516
-
517
- _defineProperty(_assertThisInitialized(_this5), "baseResponse", void 0);
518
-
519
- Object.setPrototypeOf(_assertThisInitialized(_this5), BadRequestError.prototype); // Maintains proper stack trace for where our error was thrown (only available on V8)
351
+ // Set the prototype explicitly.
352
+ _defineProperty(_this5, "baseResponse", void 0);
353
+ Object.setPrototypeOf(_this5, BadRequestError.prototype);
520
354
 
355
+ // Maintains proper stack trace for where our error was thrown (only available on V8)
521
356
  if (Error.captureStackTrace) {
522
- Error.captureStackTrace(_assertThisInitialized(_this5), BadRequestError);
357
+ Error.captureStackTrace(_this5, BadRequestError);
523
358
  }
524
-
525
359
  _this5.name = 'BadRequestError';
526
360
  _this5.baseResponse = baseResponse;
527
361
  return _this5;
528
362
  }
529
-
530
- return BadRequestError;
363
+ _inherits(BadRequestError, _HttpError2);
364
+ return _createClass(BadRequestError);
531
365
  }(HttpError); // 401
532
-
533
-
534
- var UnauthorizedError = /*#__PURE__*/function (_BadRequestError) {
535
- _inherits(UnauthorizedError, _BadRequestError);
536
-
537
- var _super6 = _createSuper(UnauthorizedError);
538
-
366
+ var UnauthorizedError = /*#__PURE__*/function (_BadRequestError2) {
539
367
  function UnauthorizedError(message, baseResponse) {
540
368
  var _this6;
541
-
542
369
  _classCallCheck(this, UnauthorizedError);
370
+ _this6 = _callSuper(this, UnauthorizedError, [message || 'Unauthorized', baseResponse]);
543
371
 
544
- _this6 = _super6.call(this, message || 'Unauthorized', baseResponse); // Set the prototype explicitly.
545
-
546
- _defineProperty(_assertThisInitialized(_this6), "baseResponse", void 0);
547
-
548
- Object.setPrototypeOf(_assertThisInitialized(_this6), UnauthorizedError.prototype); // Maintains proper stack trace for where our error was thrown (only available on V8)
372
+ // Set the prototype explicitly.
373
+ _defineProperty(_this6, "baseResponse", void 0);
374
+ Object.setPrototypeOf(_this6, UnauthorizedError.prototype);
549
375
 
376
+ // Maintains proper stack trace for where our error was thrown (only available on V8)
550
377
  if (Error.captureStackTrace) {
551
- Error.captureStackTrace(_assertThisInitialized(_this6), UnauthorizedError);
378
+ Error.captureStackTrace(_this6, UnauthorizedError);
552
379
  }
553
-
554
380
  _this6.name = 'UnauthorizedError';
555
381
  _this6.baseResponse = baseResponse;
556
382
  return _this6;
557
383
  }
558
-
559
- return UnauthorizedError;
384
+ _inherits(UnauthorizedError, _BadRequestError2);
385
+ return _createClass(UnauthorizedError);
560
386
  }(BadRequestError); // 403
561
-
562
-
563
- var ForbiddenError = /*#__PURE__*/function (_BadRequestError2) {
564
- _inherits(ForbiddenError, _BadRequestError2);
565
-
566
- var _super7 = _createSuper(ForbiddenError);
567
-
387
+ var ForbiddenError = /*#__PURE__*/function (_BadRequestError3) {
568
388
  function ForbiddenError(message, baseResponse) {
569
389
  var _this7;
570
-
571
390
  _classCallCheck(this, ForbiddenError);
391
+ _this7 = _callSuper(this, ForbiddenError, [message || 'Forbidden', baseResponse]);
572
392
 
573
- _this7 = _super7.call(this, message || 'Forbidden', baseResponse); // Set the prototype explicitly.
574
-
575
- _defineProperty(_assertThisInitialized(_this7), "baseResponse", void 0);
576
-
577
- Object.setPrototypeOf(_assertThisInitialized(_this7), ForbiddenError.prototype); // Maintains proper stack trace for where our error was thrown (only available on V8)
393
+ // Set the prototype explicitly.
394
+ _defineProperty(_this7, "baseResponse", void 0);
395
+ Object.setPrototypeOf(_this7, ForbiddenError.prototype);
578
396
 
397
+ // Maintains proper stack trace for where our error was thrown (only available on V8)
579
398
  if (Error.captureStackTrace) {
580
- Error.captureStackTrace(_assertThisInitialized(_this7), ForbiddenError);
399
+ Error.captureStackTrace(_this7, ForbiddenError);
581
400
  }
582
-
583
401
  _this7.name = 'ForbiddenError';
584
402
  _this7.baseResponse = baseResponse;
585
403
  return _this7;
586
404
  }
587
-
588
- return ForbiddenError;
405
+ _inherits(ForbiddenError, _BadRequestError3);
406
+ return _createClass(ForbiddenError);
589
407
  }(BadRequestError); // 404
590
-
591
-
592
- var ResourceNotFoundError = /*#__PURE__*/function (_BadRequestError3) {
593
- _inherits(ResourceNotFoundError, _BadRequestError3);
594
-
595
- var _super8 = _createSuper(ResourceNotFoundError);
596
-
408
+ var ResourceNotFoundError = /*#__PURE__*/function (_BadRequestError4) {
597
409
  function ResourceNotFoundError(message, baseResponse) {
598
410
  var _this8;
599
-
600
411
  _classCallCheck(this, ResourceNotFoundError);
412
+ _this8 = _callSuper(this, ResourceNotFoundError, [message || 'Resource is not found', baseResponse]);
601
413
 
602
- _this8 = _super8.call(this, message || 'Resource is not found', baseResponse); // Set the prototype explicitly.
603
-
604
- _defineProperty(_assertThisInitialized(_this8), "baseResponse", void 0);
605
-
606
- Object.setPrototypeOf(_assertThisInitialized(_this8), ResourceNotFoundError.prototype); // Maintains proper stack trace for where our error was thrown (only available on V8)
414
+ // Set the prototype explicitly.
415
+ _defineProperty(_this8, "baseResponse", void 0);
416
+ Object.setPrototypeOf(_this8, ResourceNotFoundError.prototype);
607
417
 
418
+ // Maintains proper stack trace for where our error was thrown (only available on V8)
608
419
  if (Error.captureStackTrace) {
609
- Error.captureStackTrace(_assertThisInitialized(_this8), ResourceNotFoundError);
420
+ Error.captureStackTrace(_this8, ResourceNotFoundError);
610
421
  }
611
-
612
422
  _this8.name = 'ResourceNotFoundError';
613
423
  _this8.baseResponse = baseResponse;
614
424
  return _this8;
615
425
  }
616
-
617
- return ResourceNotFoundError;
426
+ _inherits(ResourceNotFoundError, _BadRequestError4);
427
+ return _createClass(ResourceNotFoundError);
618
428
  }(BadRequestError); // 409
619
-
620
-
621
- var ConflictError = /*#__PURE__*/function (_BadRequestError4) {
622
- _inherits(ConflictError, _BadRequestError4);
623
-
624
- var _super9 = _createSuper(ConflictError);
625
-
429
+ var ConflictError = /*#__PURE__*/function (_BadRequestError5) {
626
430
  function ConflictError(message, baseResponse) {
627
431
  var _this9;
628
-
629
432
  _classCallCheck(this, ConflictError);
433
+ _this9 = _callSuper(this, ConflictError, [message || 'Conflict detected', baseResponse]);
630
434
 
631
- _this9 = _super9.call(this, message || 'Conflict detected', baseResponse); // Set the prototype explicitly.
632
-
633
- _defineProperty(_assertThisInitialized(_this9), "baseResponse", void 0);
634
-
635
- Object.setPrototypeOf(_assertThisInitialized(_this9), ConflictError.prototype); // Maintains proper stack trace for where our error was thrown (only available on V8)
435
+ // Set the prototype explicitly.
436
+ _defineProperty(_this9, "baseResponse", void 0);
437
+ Object.setPrototypeOf(_this9, ConflictError.prototype);
636
438
 
439
+ // Maintains proper stack trace for where our error was thrown (only available on V8)
637
440
  if (Error.captureStackTrace) {
638
- Error.captureStackTrace(_assertThisInitialized(_this9), ConflictError);
441
+ Error.captureStackTrace(_this9, ConflictError);
639
442
  }
640
-
641
443
  _this9.name = 'ConflictError';
642
444
  _this9.baseResponse = baseResponse;
643
445
  return _this9;
644
446
  }
645
-
646
- return ConflictError;
447
+ _inherits(ConflictError, _BadRequestError5);
448
+ return _createClass(ConflictError);
647
449
  }(BadRequestError); // 500
648
-
649
-
650
- var InternalServerError = /*#__PURE__*/function (_HttpError2) {
651
- _inherits(InternalServerError, _HttpError2);
652
-
653
- var _super10 = _createSuper(InternalServerError);
654
-
450
+ var InternalServerError = /*#__PURE__*/function (_HttpError3) {
655
451
  function InternalServerError(message, baseResponse) {
656
- var _this10;
657
-
452
+ var _this0;
658
453
  _classCallCheck(this, InternalServerError);
454
+ _this0 = _callSuper(this, InternalServerError, [message || 'Internal server error', baseResponse]);
659
455
 
660
- _this10 = _super10.call(this, message || 'Internal server error', baseResponse); // Set the prototype explicitly.
661
-
662
- _defineProperty(_assertThisInitialized(_this10), "baseResponse", void 0);
663
-
664
- Object.setPrototypeOf(_assertThisInitialized(_this10), InternalServerError.prototype); // Maintains proper stack trace for where our error was thrown (only available on V8)
456
+ // Set the prototype explicitly.
457
+ _defineProperty(_this0, "baseResponse", void 0);
458
+ Object.setPrototypeOf(_this0, InternalServerError.prototype);
665
459
 
460
+ // Maintains proper stack trace for where our error was thrown (only available on V8)
666
461
  if (Error.captureStackTrace) {
667
- Error.captureStackTrace(_assertThisInitialized(_this10), InternalServerError);
462
+ Error.captureStackTrace(_this0, InternalServerError);
668
463
  }
669
-
670
- _this10.name = 'InternalServerError';
671
- _this10.baseResponse = baseResponse;
672
- return _this10;
464
+ _this0.name = 'InternalServerError';
465
+ _this0.baseResponse = baseResponse;
466
+ return _this0;
673
467
  }
674
-
675
- return InternalServerError;
468
+ _inherits(InternalServerError, _HttpError3);
469
+ return _createClass(InternalServerError);
676
470
  }(HttpError);
677
471
  /**
678
472
  * @returns {HttpError}
679
473
  */
680
-
681
-
682
474
  function getHttpErrorFromResponse(originalResponse) {
683
475
  var response = originalResponse.clone();
684
-
685
476
  switch (true) {
686
477
  case response.status === 401:
687
478
  return new UnauthorizedError(null, response);
688
-
689
479
  case response.status === 403:
690
480
  return new ForbiddenError(null, response);
691
-
692
481
  case response.status === 404:
693
482
  return new ResourceNotFoundError(null, response);
694
-
695
483
  case response.status === 409:
696
484
  return new ConflictError(null, response);
697
-
698
485
  case response.status >= 400 && response.status < 500:
699
486
  return new BadRequestError(null, response);
700
-
701
487
  case response.status >= 500 && response.status < 600:
702
488
  return new InternalServerError(null, response);
703
-
704
489
  default:
705
490
  return new HttpError(null, response);
706
491
  }
707
492
  }
708
-
709
493
  function isOauthError(body) {
710
- var _ref;
711
-
712
- return typeof ((_ref = body) === null || _ref === void 0 ? void 0 : _ref.error) === 'string';
494
+ return typeof (body === null || body === void 0 ? void 0 : body.error) === 'string';
713
495
  }
714
496
 
715
497
  var DEFAULT_CONFIG = {
716
498
  collectionKey: 'hydra:member'
717
499
  };
718
-
719
- var _config = new WeakMap();
720
-
721
- var _classMetadataList = new WeakMap();
722
-
500
+ var _config = /*#__PURE__*/new WeakMap();
501
+ var _classMetadataList = /*#__PURE__*/new WeakMap();
723
502
  var Mapping = /*#__PURE__*/function () {
724
503
  function Mapping() {
725
504
  var idPrefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
726
505
  var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
727
-
728
506
  _classCallCheck(this, Mapping);
729
-
730
507
  _defineProperty(this, "idPrefix", void 0);
731
-
732
- _config.set(this, {
733
- writable: true,
734
- value: void 0
735
- });
736
-
737
- _classMetadataList.set(this, {
738
- writable: true,
739
- value: void 0
740
- });
741
-
508
+ _classPrivateFieldInitSpec(this, _config, void 0);
509
+ _classPrivateFieldInitSpec(this, _classMetadataList, void 0);
742
510
  this.idPrefix = idPrefix;
743
-
744
- _classPrivateFieldSet(this, _classMetadataList, []);
745
-
511
+ _classPrivateFieldSet2(_classMetadataList, this, []);
746
512
  this.setConfig(config);
747
513
  }
748
-
749
- _createClass(Mapping, [{
514
+ return _createClass(Mapping, [{
750
515
  key: "getConfig",
751
516
  value: function getConfig() {
752
- return _classPrivateFieldGet(this, _config);
517
+ return _classPrivateFieldGet2(_config, this);
753
518
  }
754
519
  }, {
755
520
  key: "setConfig",
756
521
  value: function setConfig(config) {
757
- _classPrivateFieldSet(this, _config, _objectSpread2(_objectSpread2({}, DEFAULT_CONFIG), config));
522
+ _classPrivateFieldSet2(_config, this, _objectSpread2(_objectSpread2({}, DEFAULT_CONFIG), config));
758
523
  }
759
524
  }, {
760
525
  key: "setMapping",
761
526
  value: function setMapping() {
762
527
  var classMetadataList = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
763
-
764
- _classPrivateFieldSet(this, _classMetadataList, classMetadataList);
528
+ _classPrivateFieldSet2(_classMetadataList, this, classMetadataList);
765
529
  }
766
530
  }, {
767
531
  key: "getMappingKeys",
768
532
  value: function getMappingKeys() {
769
- return _classPrivateFieldGet(this, _classMetadataList).map(function (classMetadata) {
533
+ return _classPrivateFieldGet2(_classMetadataList, this).map(function (classMetadata) {
770
534
  return classMetadata.key;
771
535
  });
772
536
  }
773
537
  }, {
774
538
  key: "getClassMetadataByKey",
775
539
  value: function getClassMetadataByKey(key) {
776
- var filterList = _classPrivateFieldGet(this, _classMetadataList).filter(function (classMetadata) {
540
+ var filterList = _classPrivateFieldGet2(_classMetadataList, this).filter(function (classMetadata) {
777
541
  return classMetadata.key === key;
778
542
  });
779
-
780
543
  return filterList.length > 0 ? filterList[0] : null;
781
544
  }
782
545
  }, {
783
546
  key: "isMappingValid",
784
547
  value: function isMappingValid() {
785
548
  var _this = this;
786
-
787
- return !_classPrivateFieldGet(this, _classMetadataList).some(function (classMetadata) {
549
+ return !_classPrivateFieldGet2(_classMetadataList, this).some(function (classMetadata) {
788
550
  // check that the relations exists
789
551
  var errorList = Object.values(classMetadata.getAttributeList()).map(function (attribute) {
790
552
  var relation = classMetadata.getRelation(attribute.serializedKey);
791
-
792
553
  if (!relation) {
793
554
  // attribute can not be "invalid" (for now ?)
794
555
  return false;
795
556
  }
557
+ var relationMetadata = _this.getClassMetadataByKey(relation.targetMetadataKey);
796
558
 
797
- var relationMetadata = _this.getClassMetadataByKey(relation.targetMetadataKey); // relation name seems weird
798
-
799
-
559
+ // relation name seems weird
800
560
  if (relation.isRelationToOne() && attribute.attributeName.endsWith('List')) {
801
561
  return "\"".concat(classMetadata.key, ".").concat(attribute.serializedKey, " is defined as a MANY_TO_ONE relation, but the attribute name ends with \"List\".");
802
562
  }
803
-
804
563
  if (relation.isRelationToMany()) {
805
564
  var message = "\"".concat(classMetadata.key, ".").concat(attribute.serializedKey, " is defined as a ").concat(relation.type, " relation, but the attribute name is nor plural not ends with \"List\".");
806
565
  var endsWithList = attribute.attributeName.endsWith('List');
807
-
808
566
  try {
809
- // eslint-disable-next-line global-require, import/no-extraneous-dependencies, @typescript-eslint/no-var-requires
567
+ // eslint-disable-next-line @typescript-eslint/no-require-imports
810
568
  var pluralize = require('pluralize');
811
-
812
569
  if (!endsWithList && !pluralize.isPlural(attribute.attributeName)) {
813
570
  return message;
814
571
  }
815
- } catch (e) {
572
+ } catch (_unused) {
816
573
  if (!endsWithList) {
817
574
  return "".concat(message, ".\nIf your keys does not ends with \"List\", then you should install the \"pluralize\" package.");
818
575
  }
819
576
  }
820
- } // no error if there is metadata linked
821
-
577
+ }
822
578
 
579
+ // no error if there is metadata linked
823
580
  if (!relationMetadata) {
824
581
  return "\"".concat(classMetadata.key, ".").concat(attribute.serializedKey, "\" defined a relation to the metadata named \"").concat(relation.targetMetadataKey, "\" but this metadata is not knowned by the mapping");
825
582
  }
826
-
827
583
  return false;
828
584
  });
829
-
830
585
  if (!classMetadata.hasIdentifierAttribute()) {
831
586
  errorList.push("\"".concat(classMetadata.key, "\" has no identifier attribute set"));
832
587
  }
833
-
834
588
  var nbError = errorList.filter(function (error) {
835
589
  if (error) {
836
- // eslint-disable-next-line no-console
837
590
  console.warn(error);
838
591
  }
839
-
840
592
  return error;
841
593
  });
842
594
  return nbError.length > 0;
843
595
  });
844
596
  }
845
597
  }]);
846
-
847
- return Mapping;
848
598
  }();
849
599
 
850
- var Attribute =
600
+ var Attribute = /*#__PURE__*/_createClass(
851
601
  /**
852
602
  * @param {string} serializedKey the key returned from your API
853
603
  * @param {null|string} attributeName the name in your entity, default to the `serializedKey` attribute
@@ -858,143 +608,104 @@
858
608
  var attributeName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
859
609
  var type = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'string';
860
610
  var isIdentifier = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
861
-
862
611
  _classCallCheck(this, Attribute);
863
-
864
612
  _defineProperty(this, "serializedKey", void 0);
865
-
866
613
  _defineProperty(this, "attributeName", void 0);
867
-
868
614
  _defineProperty(this, "type", void 0);
869
-
870
615
  _defineProperty(this, "isIdentifier", void 0);
871
-
872
616
  if (!serializedKey) {
873
617
  throw new TypeError('`serializedKey` must not be empty');
874
618
  }
875
-
876
619
  this.serializedKey = serializedKey;
877
620
  this.attributeName = attributeName || this.serializedKey;
878
621
  this.type = type;
879
622
  this.isIdentifier = isIdentifier;
880
- };
623
+ });
881
624
 
882
- /* eslint-disable import/prefer-default-export */
883
- // eslint-disable-next-line import/no-duplicates
884
- // eslint-disable-next-line import/no-duplicates
885
625
  function generateRepository(sdk, metadata) {
886
626
  var isUnitOfWorkEnabled = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
887
627
  // eslint-disable-next-line new-cap
888
628
  return new metadata.repositoryClass(sdk, metadata, isUnitOfWorkEnabled);
889
629
  }
890
630
 
891
- /* eslint-disable consistent-return */
892
631
  function removeAuthorization(headers) {
893
632
  if (!headers) {
894
633
  return;
895
634
  }
896
-
897
635
  if (headers instanceof Headers) {
898
636
  headers["delete"]('Authorization');
899
637
  return headers;
900
638
  }
901
-
902
639
  var filterAuthorization = function filterAuthorization(entries) {
903
640
  return entries.filter(function (header) {
904
641
  return header[0] !== 'Authorization';
905
642
  });
906
643
  };
907
-
908
644
  if (Array.isArray(headers)) {
909
645
  return filterAuthorization(headers);
910
646
  }
911
-
912
647
  return Object.fromEntries(filterAuthorization(Object.entries(headers)));
913
648
  }
649
+
914
650
  /**
915
651
  * remove undefined key, usefull to remove Content-Type for example.
916
652
  * Does not apply on "Headers" instance as values are string in there.
917
653
  */
918
-
919
654
  function removeUndefinedHeaders(headers) {
920
655
  if (headers instanceof Headers) {
921
656
  return headers;
922
657
  }
923
-
924
658
  var filterEntries = function filterEntries(entries) {
925
659
  return entries.filter(function (header) {
926
660
  return header[1] !== undefined;
927
661
  });
928
662
  };
929
-
930
663
  if (Array.isArray(headers)) {
931
664
  return filterEntries(headers);
932
665
  }
933
-
934
666
  return Object.fromEntries(filterEntries(Object.entries(headers)));
935
667
  }
936
668
  function convertToRecord(headers) {
937
669
  if (headers instanceof Headers) {
938
670
  return Object.fromEntries(headers.entries());
939
671
  }
940
-
941
672
  if (Array.isArray(headers)) {
942
673
  return Object.fromEntries(headers);
943
674
  }
944
-
945
675
  return headers;
946
676
  }
947
677
 
948
- var EXPIRE_LIMIT_SECONDS = 300; // = 5 minutes
949
-
950
- var _tokenStorage = new WeakMap();
951
-
952
- var _isUnitOfWorkEnabled = new WeakMap();
953
-
678
+ var _excluded = ["headers"];
679
+ var EXPIRE_LIMIT_SECONDS = 300; // = 5 minutes
680
+ var _tokenStorage = /*#__PURE__*/new WeakMap();
681
+ var _isUnitOfWorkEnabled = /*#__PURE__*/new WeakMap();
954
682
  var AbstractClient = /*#__PURE__*/function () {
955
683
  function AbstractClient(sdk, metadata) {
956
684
  var isUnitOfWorkEnabled = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
957
-
958
685
  _classCallCheck(this, AbstractClient);
959
-
960
686
  _defineProperty(this, "sdk", void 0);
961
-
962
- _tokenStorage.set(this, {
963
- writable: true,
964
- value: void 0
965
- });
966
-
687
+ _classPrivateFieldInitSpec(this, _tokenStorage, void 0);
967
688
  _defineProperty(this, "serializer", void 0);
968
-
969
689
  _defineProperty(this, "metadata", void 0);
970
-
971
- _isUnitOfWorkEnabled.set(this, {
972
- writable: true,
973
- value: void 0
974
- });
975
-
690
+ _classPrivateFieldInitSpec(this, _isUnitOfWorkEnabled, void 0);
976
691
  this.sdk = sdk;
977
-
978
- _classPrivateFieldSet(this, _tokenStorage, sdk.tokenStorage);
979
-
692
+ _classPrivateFieldSet2(_tokenStorage, this, sdk.tokenStorage);
980
693
  this.serializer = sdk.serializer;
981
694
  this.metadata = metadata;
982
-
983
- _classPrivateFieldSet(this, _isUnitOfWorkEnabled, isUnitOfWorkEnabled);
695
+ _classPrivateFieldSet2(_isUnitOfWorkEnabled, this, isUnitOfWorkEnabled);
984
696
  }
985
-
986
- _createClass(AbstractClient, [{
697
+ return _createClass(AbstractClient, [{
987
698
  key: "withUnitOfWork",
988
699
  value: function withUnitOfWork(enabled) {
989
- // eslint-disable-next-line new-cap
990
700
  return generateRepository(this.sdk, this.metadata, enabled);
991
701
  }
992
702
  }, {
993
703
  key: "getDefaultParameters",
994
704
  value: function getDefaultParameters() {
995
705
  return {};
996
- } // eslint-disable-next-line @typescript-eslint/no-unused-vars
706
+ }
997
707
 
708
+ // eslint-disable-next-line @typescript-eslint/no-unused-vars
998
709
  }, {
999
710
  key: "getPathBase",
1000
711
  value: function getPathBase(pathParameters) {
@@ -1004,11 +715,9 @@
1004
715
  key: "getEntityURI",
1005
716
  value: function getEntityURI(entity) {
1006
717
  var idValue = this._getEntityIdentifier(entity);
1007
-
1008
718
  if (idValue === null) {
1009
719
  throw new Error('Cannot call `getEntityURI for entity without id.`');
1010
720
  }
1011
-
1012
721
  if (typeof idValue === 'number') {
1013
722
  if (Number.isFinite(idValue)) {
1014
723
  idValue = idValue.toString();
@@ -1016,15 +725,13 @@
1016
725
  throw new Error('Unable to handle non-finite number');
1017
726
  }
1018
727
  }
1019
-
1020
728
  var pathBase = this.getPathBase({});
1021
-
1022
729
  if (idValue.indexOf(pathBase) > -1) {
1023
730
  return idValue;
1024
731
  }
1025
-
1026
732
  return "".concat(pathBase, "/").concat(idValue);
1027
733
  }
734
+
1028
735
  /**
1029
736
  * get an entity by its id
1030
737
  *
@@ -1033,18 +740,16 @@
1033
740
  * @param {Record<string, unknown>} pathParameters path parameters, will be pass to the `getPathBase` method
1034
741
  * @param {Record<string, unknown>} requestParams parameters that will be send as second parameter to the `fetch` call
1035
742
  */
1036
-
1037
743
  }, {
1038
744
  key: "find",
1039
745
  value: function find(id) {
1040
746
  var queryParam = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
1041
747
  var pathParameters = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
1042
748
  var requestParams = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
1043
-
1044
749
  var url = this._generateUrlFromParams(queryParam, pathParameters, id);
1045
-
1046
750
  return this.deserializeResponse(this.authorizedFetch(url, requestParams), 'item');
1047
751
  }
752
+
1048
753
  /**
1049
754
  * get a list of entities by some parameters
1050
755
  *
@@ -1052,17 +757,15 @@
1052
757
  * @param {Record<string, unknown>} pathParameters path parameters, will be pass to the `getPathBase` method
1053
758
  * @param {Record<string, unknown>} requestParams parameters that will be send as second parameter to the `fetch` call
1054
759
  */
1055
-
1056
760
  }, {
1057
761
  key: "findBy",
1058
762
  value: function findBy(queryParam) {
1059
763
  var pathParameters = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
1060
764
  var requestParams = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
1061
-
1062
765
  var url = this._generateUrlFromParams(queryParam, pathParameters);
1063
-
1064
766
  return this.deserializeResponse(this.authorizedFetch(url, requestParams), 'list');
1065
767
  }
768
+
1066
769
  /**
1067
770
  * get a list of all entities
1068
771
  *
@@ -1070,7 +773,6 @@
1070
773
  * @param {Record<string, unknown>} pathParameters path parameters, will be pass to the `getPathBase` method
1071
774
  * @param {Record<string, unknown>} requestParams parameters that will be send as second parameter to the `fetch` call
1072
775
  */
1073
-
1074
776
  }, {
1075
777
  key: "findAll",
1076
778
  value: function findAll() {
@@ -1079,6 +781,7 @@
1079
781
  var requestParams = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
1080
782
  return this.findBy(queryParam, pathParameters, requestParams);
1081
783
  }
784
+
1082
785
  /**
1083
786
  * create an entity
1084
787
  *
@@ -1087,7 +790,6 @@
1087
790
  * @param {Record<string, unknown>} pathParameters path parameters, will be pass to the `getPathBase` method
1088
791
  * @param {Record<string, unknown>} requestParams parameters that will be send as second parameter to the `fetch` call
1089
792
  */
1090
-
1091
793
  }, {
1092
794
  key: "create",
1093
795
  value: function create(entity) {
@@ -1104,6 +806,7 @@
1104
806
  body: this.serializer.encodeItem(diff, this.metadata)
1105
807
  }, requestParams)), 'item');
1106
808
  }
809
+
1107
810
  /**
1108
811
  * update an entity
1109
812
  *
@@ -1111,57 +814,69 @@
1111
814
  * @param {Record<string, unknown>} queryParam query parameters that will be added to the request
1112
815
  * @param {Record<string, unknown>} requestParams parameters that will be send as second parameter to the `fetch` call
1113
816
  */
1114
-
1115
817
  }, {
1116
818
  key: "update",
1117
819
  value: function update(entity) {
1118
820
  var queryParam = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
1119
821
  var requestParams = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
822
+ return this._update('PUT', entity, queryParam, requestParams);
823
+ }
824
+
825
+ /**
826
+ * partially update an entity using the `PATCH` HTTP verb
827
+ *
828
+ * @param {Record<string, unknown>} entity the entity to update
829
+ * @param {Record<string, unknown>} queryParam query parameters that will be added to the request
830
+ * @param {Record<string, unknown>} requestParams parameters that will be send as second parameter to the `fetch` call
831
+ */
832
+ }, {
833
+ key: "patch",
834
+ value: function patch(entity) {
835
+ var queryParam = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
836
+ var requestParams = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
837
+ return this._update('PATCH', entity, queryParam, requestParams);
838
+ }
839
+ }, {
840
+ key: "_update",
841
+ value: function _update(method, entity) {
842
+ var queryParam = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
843
+ var requestParams = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
1120
844
  var url = new URI(this.getEntityURI(entity));
1121
845
  url.addSearch(queryParam);
1122
846
  var newSerializedModel = this.serializer.normalizeItem(entity, this.metadata);
1123
-
1124
847
  var identifier = this._getEntityIdentifier(newSerializedModel);
1125
-
1126
848
  var oldModel;
1127
-
1128
849
  if (identifier !== null) {
1129
850
  oldModel = this.sdk.unitOfWork.getDirtyEntity(identifier);
1130
851
  }
1131
-
1132
852
  if (oldModel) {
1133
853
  newSerializedModel = this.sdk.unitOfWork.getDirtyData(newSerializedModel, oldModel, this.metadata);
1134
854
  }
1135
-
1136
855
  return this.deserializeResponse(this.authorizedFetch(url, _objectSpread2({
1137
- method: 'PUT',
856
+ method: method,
1138
857
  body: this.serializer.encodeItem(newSerializedModel, this.metadata)
1139
858
  }, requestParams)), 'item');
1140
859
  }
860
+
1141
861
  /**
1142
862
  * delete an entity
1143
863
  *
1144
864
  * @param {Record<string, unknown>} the entity to delete
1145
865
  * @param {Record<string, unknown>} requestParams parameters that will be send as second parameter to the `fetch` call
1146
866
  */
1147
-
1148
867
  }, {
1149
868
  key: "delete",
1150
869
  value: function _delete(entity) {
1151
870
  var _this = this;
1152
-
1153
871
  var requestParams = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
1154
872
  var url = this.getEntityURI(entity);
1155
-
1156
873
  var identifier = this._getEntityIdentifier(entity);
1157
-
1158
874
  return this.authorizedFetch(url, _objectSpread2({
1159
875
  method: 'DELETE'
1160
876
  }, requestParams)).then(function (response) {
1161
877
  if (identifier !== null) {
1162
878
  _this.sdk.unitOfWork.clear(identifier);
1163
879
  }
1164
-
1165
880
  return response;
1166
881
  });
1167
882
  }
@@ -1169,7 +884,6 @@
1169
884
  key: "deserializeResponse",
1170
885
  value: function deserializeResponse(requestPromise, listOrItem) {
1171
886
  var _this2 = this;
1172
-
1173
887
  return requestPromise.then(function (response) {
1174
888
  return response.text().then(function (text) {
1175
889
  return {
@@ -1179,26 +893,20 @@
1179
893
  });
1180
894
  }).then(function (_ref) {
1181
895
  var response = _ref.response,
1182
- text = _ref.text;
1183
-
896
+ text = _ref.text;
1184
897
  if (listOrItem === 'list') {
1185
898
  // for list, we need to deserialize the result to get an object
1186
899
  var itemList = _this2.serializer.deserializeList(text, _this2.metadata, response);
1187
-
1188
- if (_classPrivateFieldGet(_this2, _isUnitOfWorkEnabled)) {
1189
- // eslint-disable-next-line no-restricted-syntax
900
+ if (_classPrivateFieldGet2(_isUnitOfWorkEnabled, _this2)) {
1190
901
  var _iterator = _createForOfIteratorHelper(itemList),
1191
- _step;
1192
-
902
+ _step;
1193
903
  try {
1194
904
  for (_iterator.s(); !(_step = _iterator.n()).done;) {
1195
905
  var _decodedItem = _step.value;
1196
-
1197
906
  var _identifier = _this2._getEntityIdentifier(_decodedItem);
907
+ var normalizedItem = _this2.serializer.normalizeItem(_decodedItem, _this2.metadata);
1198
908
 
1199
- var normalizedItem = _this2.serializer.normalizeItem(_decodedItem, _this2.metadata); // then we register the re-normalized item
1200
-
1201
-
909
+ // then we register the re-normalized item
1202
910
  if (_identifier !== null) {
1203
911
  _this2.sdk.unitOfWork.registerClean(_identifier, normalizedItem);
1204
912
  }
@@ -1209,23 +917,20 @@
1209
917
  _iterator.f();
1210
918
  }
1211
919
  }
1212
-
1213
920
  return itemList;
1214
- } // for items, we can just decode the item (ie. transform it to JS object)
1215
-
1216
-
1217
- var decodedItem = _this2.serializer.decodeItem(text, _this2.metadata, response); // and register it directy without deserializing + renormalizing
1218
-
921
+ }
1219
922
 
1220
- var identifier = _this2._getEntityIdentifier(decodedItem); // and finally return the denormalized item
923
+ // for items, we can just decode the item (ie. transform it to JS object)
924
+ var decodedItem = _this2.serializer.decodeItem(text, _this2.metadata, response);
1221
925
 
926
+ // and register it directy without deserializing + renormalizing
927
+ var identifier = _this2._getEntityIdentifier(decodedItem);
1222
928
 
929
+ // and finally return the denormalized item
1223
930
  var item = _this2.serializer.denormalizeItem(decodedItem, _this2.metadata, response);
1224
-
1225
- if (_classPrivateFieldGet(_this2, _isUnitOfWorkEnabled) && identifier !== null) {
931
+ if (_classPrivateFieldGet2(_isUnitOfWorkEnabled, _this2) && identifier !== null) {
1226
932
  _this2.sdk.unitOfWork.registerClean(identifier, _this2.serializer.normalizeItem(item, _this2.metadata));
1227
933
  }
1228
-
1229
934
  return item;
1230
935
  });
1231
936
  }
@@ -1234,20 +939,16 @@
1234
939
  value: function makeUri(input) {
1235
940
  var url = input instanceof URI ? input : new URI(input);
1236
941
  url.host(this.sdk.config.path).scheme(this.sdk.config.scheme);
1237
-
1238
942
  if (this.sdk.config.port) {
1239
943
  url.port(String(this.sdk.config.port));
1240
944
  }
1241
-
1242
945
  if (this.sdk.mapping.idPrefix) {
1243
946
  var segments = url.segment();
1244
-
1245
947
  if (!url.pathname().startsWith(this.sdk.mapping.idPrefix)) {
1246
948
  segments.unshift(this.sdk.mapping.idPrefix);
1247
949
  url.segment(segments);
1248
950
  }
1249
951
  }
1250
-
1251
952
  return url;
1252
953
  }
1253
954
  }, {
@@ -1263,17 +964,13 @@
1263
964
  var pathParameters = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
1264
965
  var id = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
1265
966
  var params = queryParam;
1266
-
1267
967
  if (this.sdk.config.useDefaultParameters) {
1268
968
  Object.assign(params, this.getDefaultParameters());
1269
969
  }
1270
-
1271
970
  var pathBase = this.getPathBase(pathParameters);
1272
- var url = null;
1273
-
971
+ var url;
1274
972
  if (id) {
1275
973
  var testPathBase = this.sdk.mapping.idPrefix ? "".concat(this.sdk.mapping.idPrefix).concat(pathBase) : pathBase;
1276
-
1277
974
  if (typeof id === 'string' && id.startsWith(testPathBase)) {
1278
975
  url = new URI(id);
1279
976
  } else {
@@ -1282,63 +979,51 @@
1282
979
  } else {
1283
980
  url = new URI(pathBase);
1284
981
  }
1285
-
1286
982
  if (params) {
1287
983
  url.addSearch(params);
1288
984
  }
1289
-
1290
985
  return url;
1291
986
  }
1292
987
  }, {
1293
988
  key: "_fetchWithToken",
1294
989
  value: function _fetchWithToken(input) {
1295
990
  var _this3 = this;
1296
-
1297
991
  var requestParams = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
1298
-
1299
992
  if (!input) {
1300
993
  throw new Error('input is empty');
1301
994
  }
1302
-
1303
- if (_classPrivateFieldGet(this, _tokenStorage)) {
1304
- return _classPrivateFieldGet(this, _tokenStorage).getCurrentTokenExpiresIn().then(function (accessTokenExpiresIn) {
995
+ if (_classPrivateFieldGet2(_tokenStorage, this)) {
996
+ return _classPrivateFieldGet2(_tokenStorage, this).getCurrentTokenExpiresIn().then(function (accessTokenExpiresIn) {
1305
997
  if (accessTokenExpiresIn !== null && accessTokenExpiresIn <= EXPIRE_LIMIT_SECONDS) {
1306
- return _classPrivateFieldGet(_this3, _tokenStorage).refreshToken().then(function (refreshedTokenObject) {
998
+ return _classPrivateFieldGet2(_tokenStorage, _this3).refreshToken().then(function (refreshedTokenObject) {
1307
999
  return refreshedTokenObject.access_token;
1308
1000
  })["catch"](function (e) {
1309
1001
  _this3._handleRefreshTokenFailure(e);
1310
-
1311
1002
  throw e;
1312
1003
  });
1313
1004
  }
1314
-
1315
- return _classPrivateFieldGet(_this3, _tokenStorage).getAccessToken();
1005
+ return _classPrivateFieldGet2(_tokenStorage, _this3).getAccessToken();
1316
1006
  }).then(function (token) {
1317
1007
  return _this3._doFetch(token, input, requestParams);
1318
1008
  });
1319
1009
  }
1320
-
1321
1010
  return this._doFetch(null, input, requestParams);
1322
1011
  }
1323
1012
  }, {
1324
1013
  key: "_refreshTokenAndRefetch",
1325
1014
  value: function _refreshTokenAndRefetch(input) {
1326
1015
  var _this4 = this;
1327
-
1328
1016
  var requestParams = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
1329
- return _classPrivateFieldGet(this, _tokenStorage).refreshToken().then(function () {
1017
+ return _classPrivateFieldGet2(_tokenStorage, this).refreshToken().then(function () {
1330
1018
  // eslint-disable-next-line prefer-const
1331
1019
  var headers = requestParams.headers,
1332
- rest = _objectWithoutProperties(requestParams, ["headers"]);
1333
-
1020
+ rest = _objectWithoutProperties(requestParams, _excluded);
1334
1021
  var updatedRequestParams = _objectSpread2(_objectSpread2({}, rest), {}, {
1335
1022
  headers: removeAuthorization(headers)
1336
1023
  });
1337
-
1338
1024
  return _this4._fetchWithToken(input, updatedRequestParams);
1339
1025
  })["catch"](function (e) {
1340
1026
  _this4._handleRefreshTokenFailure(e);
1341
-
1342
1027
  throw e;
1343
1028
  });
1344
1029
  }
@@ -1346,33 +1031,28 @@
1346
1031
  key: "_manageUnauthorized",
1347
1032
  value: function _manageUnauthorized(response, input) {
1348
1033
  var _this5 = this;
1349
-
1350
1034
  var requestParams = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
1351
- var error = getHttpErrorFromResponse(response); // https://tools.ietf.org/html/rfc2617#section-1.2
1035
+ var error = getHttpErrorFromResponse(response);
1352
1036
 
1037
+ // https://tools.ietf.org/html/rfc2617#section-1.2
1353
1038
  var authorizationHeader = response.headers.get('www-authenticate');
1354
-
1355
1039
  if (authorizationHeader) {
1356
1040
  var invalidGrant = authorizationHeader.indexOf('error="invalid_grant"') > -1;
1357
-
1358
- if (invalidGrant && _classPrivateFieldGet(this, _tokenStorage)) {
1041
+ if (invalidGrant && _classPrivateFieldGet2(_tokenStorage, this)) {
1359
1042
  return this._refreshTokenAndRefetch(input, requestParams);
1360
1043
  }
1361
-
1362
1044
  throw error;
1363
1045
  } else {
1364
1046
  // if www-authenticate header is missing, try and read json response
1365
1047
  return response.json().then(function (body) {
1366
- if (_classPrivateFieldGet(_this5, _tokenStorage) && (body.error === 'invalid_scope' || body.error === 'access_denied')) {
1048
+ if (_classPrivateFieldGet2(_tokenStorage, _this5) && (body.error === 'invalid_scope' || body.error === 'access_denied')) {
1367
1049
  return _this5._refreshTokenAndRefetch(input, requestParams);
1368
1050
  }
1369
-
1370
1051
  throw error;
1371
1052
  })["catch"](function (err) {
1372
1053
  if (err instanceof OauthError) {
1373
1054
  throw err;
1374
1055
  }
1375
-
1376
1056
  throw error;
1377
1057
  });
1378
1058
  }
@@ -1381,58 +1061,45 @@
1381
1061
  key: "_doFetch",
1382
1062
  value: function _doFetch(accessToken, input, requestParams) {
1383
1063
  var _this6 = this;
1384
-
1385
1064
  var params = requestParams;
1386
1065
  var baseHeaders = {};
1387
-
1388
1066
  if (params.method !== 'GET' || params.method !== 'GET' && params.method !== 'DELETE') {
1389
1067
  baseHeaders = {
1390
1068
  'Content-Type': 'application/json'
1391
1069
  };
1392
1070
  }
1393
-
1394
1071
  if (accessToken) {
1395
1072
  baseHeaders.Authorization = "".concat(this.sdk.config.authorizationType, " ").concat(accessToken);
1396
1073
  }
1397
-
1398
1074
  if (params) {
1399
1075
  if (!params.headers) {
1400
1076
  params.headers = {};
1401
1077
  }
1402
-
1403
1078
  params.headers = Object.assign(baseHeaders, params.headers);
1404
1079
  } else {
1405
1080
  params = {
1406
1081
  headers: baseHeaders
1407
1082
  };
1408
1083
  }
1409
-
1410
1084
  if (params.headers) {
1411
1085
  params.headers = removeUndefinedHeaders(params.headers);
1412
1086
  }
1413
-
1414
1087
  var logId;
1415
-
1416
1088
  if (this.sdk.logger) {
1417
1089
  logId = this.sdk.logger.logRequest(_objectSpread2({
1418
1090
  url: input
1419
1091
  }, params));
1420
- } // eslint-disable-next-line consistent-return
1421
-
1422
-
1092
+ }
1423
1093
  return fetch(input, params).then(function (response) {
1424
1094
  if (_this6.sdk.logger) {
1425
1095
  _this6.sdk.logger.logResponse(response, logId);
1426
1096
  }
1427
-
1428
1097
  if (response.status < 400) {
1429
1098
  return response;
1430
1099
  }
1431
-
1432
1100
  if (response.status === 401) {
1433
1101
  return _this6._manageUnauthorized(response, input, params);
1434
1102
  }
1435
-
1436
1103
  var httpError = getHttpErrorFromResponse(response);
1437
1104
  throw httpError;
1438
1105
  });
@@ -1440,18 +1107,18 @@
1440
1107
  }, {
1441
1108
  key: "_getEntityIdentifier",
1442
1109
  value: function _getEntityIdentifier(object) {
1443
- var idKey = this.metadata.getIdentifierAttribute().serializedKey; // eslint-disable-next-line @typescript-eslint/ban-ts-comment
1444
- // @ts-ignore
1110
+ var idKey = this.metadata.getIdentifierAttribute().serializedKey;
1445
1111
 
1112
+ // eslint-disable-next-line @typescript-eslint/ban-ts-comment
1113
+ // @ts-ignore
1446
1114
  return object[idKey];
1447
1115
  }
1448
1116
  }, {
1449
1117
  key: "_handleRefreshTokenFailure",
1450
1118
  value: function _handleRefreshTokenFailure(error) {
1451
1119
  var _this7 = this;
1452
-
1453
1120
  if (error instanceof OauthError) {
1454
- _classPrivateFieldGet(this, _tokenStorage).logout().then(function () {
1121
+ _classPrivateFieldGet2(_tokenStorage, this).logout().then(function () {
1455
1122
  if (_this7.sdk.config.onRefreshTokenFailure) {
1456
1123
  _this7.sdk.config.onRefreshTokenFailure(error);
1457
1124
  }
@@ -1459,16 +1126,11 @@
1459
1126
  }
1460
1127
  }
1461
1128
  }]);
1462
-
1463
- return AbstractClient;
1464
1129
  }();
1465
1130
 
1466
- var _attributeList = new WeakMap();
1467
-
1468
- var _relationList = new WeakMap();
1469
-
1470
- var _identifierAttribute = new WeakMap();
1471
-
1131
+ var _attributeList = /*#__PURE__*/new WeakMap();
1132
+ var _relationList = /*#__PURE__*/new WeakMap();
1133
+ var _identifierAttribute = /*#__PURE__*/new WeakMap();
1472
1134
  var ClassMetadata = /*#__PURE__*/function () {
1473
1135
  /**
1474
1136
  * @param {string} key mandatory, will be passed in your serializer
@@ -1478,86 +1140,59 @@
1478
1140
  function ClassMetadata(key) {
1479
1141
  var pathRoot = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
1480
1142
  var repositoryClass = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : AbstractClient;
1481
-
1482
1143
  _classCallCheck(this, ClassMetadata);
1483
-
1484
1144
  _defineProperty(this, "key", void 0);
1485
-
1486
1145
  _defineProperty(this, "pathRoot", void 0);
1487
-
1488
1146
  _defineProperty(this, "repositoryClass", void 0);
1489
-
1490
- _attributeList.set(this, {
1491
- writable: true,
1492
- value: void 0
1493
- });
1494
-
1495
- _relationList.set(this, {
1496
- writable: true,
1497
- value: void 0
1498
- });
1499
-
1500
- _identifierAttribute.set(this, {
1501
- writable: true,
1502
- value: void 0
1503
- });
1504
-
1147
+ _classPrivateFieldInitSpec(this, _attributeList, void 0);
1148
+ _classPrivateFieldInitSpec(this, _relationList, void 0);
1149
+ _classPrivateFieldInitSpec(this, _identifierAttribute, void 0);
1505
1150
  if (!key) {
1506
1151
  throw new TypeError('key attribute are required');
1507
1152
  }
1508
-
1509
1153
  this.key = key;
1510
- this.pathRoot = pathRoot || key; // this.modelName = modelName;
1511
-
1154
+ this.pathRoot = pathRoot || key;
1155
+ // this.modelName = modelName;
1512
1156
  this.repositoryClass = repositoryClass;
1513
-
1514
- _classPrivateFieldSet(this, _attributeList, {});
1515
-
1516
- _classPrivateFieldSet(this, _relationList, {});
1157
+ _classPrivateFieldSet2(_attributeList, this, {});
1158
+ _classPrivateFieldSet2(_relationList, this, {});
1517
1159
  }
1518
-
1519
- _createClass(ClassMetadata, [{
1160
+ return _createClass(ClassMetadata, [{
1520
1161
  key: "getAttribute",
1521
1162
  value: function getAttribute(name) {
1522
- return _classPrivateFieldGet(this, _attributeList)[name];
1163
+ return _classPrivateFieldGet2(_attributeList, this)[name];
1523
1164
  }
1524
1165
  }, {
1525
1166
  key: "hasIdentifierAttribute",
1526
1167
  value: function hasIdentifierAttribute() {
1527
- return !!_classPrivateFieldGet(this, _identifierAttribute);
1168
+ return !!_classPrivateFieldGet2(_identifierAttribute, this);
1528
1169
  }
1529
1170
  }, {
1530
1171
  key: "getIdentifierAttribute",
1531
1172
  value: function getIdentifierAttribute() {
1532
- if (!_classPrivateFieldGet(this, _identifierAttribute)) {
1173
+ if (!_classPrivateFieldGet2(_identifierAttribute, this)) {
1533
1174
  throw new TypeError("\"".concat(this.key, "\" has no identifier attribute set. Did you call \"setAttributeList\" first ?"));
1534
1175
  }
1535
-
1536
- return _classPrivateFieldGet(this, _identifierAttribute);
1176
+ return _classPrivateFieldGet2(_identifierAttribute, this);
1537
1177
  }
1538
1178
  }, {
1539
1179
  key: "getAttributeList",
1540
1180
  value: function getAttributeList() {
1541
- return _classPrivateFieldGet(this, _attributeList);
1181
+ return _classPrivateFieldGet2(_attributeList, this);
1542
1182
  }
1543
1183
  }, {
1544
1184
  key: "setAttributeList",
1545
1185
  value: function setAttributeList(attributeList) {
1546
1186
  var _this = this;
1547
-
1548
- _classPrivateFieldSet(this, _attributeList, {});
1549
-
1550
- _classPrivateFieldSet(this, _identifierAttribute, undefined);
1551
-
1187
+ _classPrivateFieldSet2(_attributeList, this, {});
1188
+ _classPrivateFieldSet2(_identifierAttribute, this, undefined);
1552
1189
  attributeList.forEach(function (attribute) {
1553
- _classPrivateFieldGet(_this, _attributeList)[attribute.serializedKey] = attribute;
1554
-
1190
+ _classPrivateFieldGet2(_attributeList, _this)[attribute.serializedKey] = attribute;
1555
1191
  if (attribute.isIdentifier) {
1556
- _classPrivateFieldSet(_this, _identifierAttribute, attribute);
1192
+ _classPrivateFieldSet2(_identifierAttribute, _this, attribute);
1557
1193
  }
1558
1194
  });
1559
-
1560
- if (!_classPrivateFieldGet(this, _identifierAttribute)) {
1195
+ if (!_classPrivateFieldGet2(_identifierAttribute, this)) {
1561
1196
  throw new TypeError("\"".concat(this.key, "\" has no identifier attribute set. You must set all your attributes in one time and send an attribute with \"isIdentifier=true\""));
1562
1197
  }
1563
1198
  }
@@ -1565,31 +1200,27 @@
1565
1200
  key: "setRelationList",
1566
1201
  value: function setRelationList(relationList) {
1567
1202
  var _this2 = this;
1568
-
1569
- _classPrivateFieldSet(this, _relationList, {});
1570
-
1203
+ _classPrivateFieldSet2(_relationList, this, {});
1571
1204
  relationList.forEach(function (relation) {
1572
- _classPrivateFieldGet(_this2, _relationList)[relation.serializedKey] = relation;
1573
- _classPrivateFieldGet(_this2, _attributeList)[relation.serializedKey] = new Attribute(relation.serializedKey, relation.serializedKey, relation.isRelationToMany() ? 'array' : 'object');
1205
+ _classPrivateFieldGet2(_relationList, _this2)[relation.serializedKey] = relation;
1206
+ _classPrivateFieldGet2(_attributeList, _this2)[relation.serializedKey] = new Attribute(relation.serializedKey, relation.serializedKey, relation.isRelationToMany() ? 'array' : 'object');
1574
1207
  });
1575
1208
  }
1576
1209
  }, {
1577
1210
  key: "getRelation",
1578
1211
  value: function getRelation(key) {
1579
- return _classPrivateFieldGet(this, _relationList)[key];
1212
+ return _classPrivateFieldGet2(_relationList, this)[key];
1580
1213
  }
1581
1214
  }, {
1582
1215
  key: "getDefaultSerializedModel",
1583
1216
  value: function getDefaultSerializedModel() {
1584
1217
  var _this3 = this;
1585
-
1586
1218
  var out = {};
1587
- Object.keys(_classPrivateFieldGet(this, _attributeList)).forEach(function (serializedKey) {
1219
+ Object.keys(_classPrivateFieldGet2(_attributeList, this)).forEach(function (serializedKey) {
1588
1220
  out[serializedKey] = null;
1589
1221
  });
1590
- Object.keys(_classPrivateFieldGet(this, _relationList)).forEach(function (serializedKey) {
1591
- var relation = _classPrivateFieldGet(_this3, _relationList)[serializedKey];
1592
-
1222
+ Object.keys(_classPrivateFieldGet2(_relationList, this)).forEach(function (serializedKey) {
1223
+ var relation = _classPrivateFieldGet2(_relationList, _this3)[serializedKey];
1593
1224
  if (relation.isRelationToMany()) {
1594
1225
  out[serializedKey] = [];
1595
1226
  }
@@ -1597,19 +1228,15 @@
1597
1228
  return out;
1598
1229
  }
1599
1230
  }]);
1600
-
1601
- return ClassMetadata;
1602
1231
  }();
1603
1232
 
1604
- var RelationTypes;
1605
-
1606
- (function (RelationTypes) {
1233
+ var RelationTypes = /*#__PURE__*/function (RelationTypes) {
1607
1234
  RelationTypes["ONE_TO_ONE"] = "ONE_TO_ONE";
1608
1235
  RelationTypes["ONE_TO_MANY"] = "ONE_TO_MANY";
1609
1236
  RelationTypes["MANY_TO_MANY"] = "MANY_TO_MANY";
1610
1237
  RelationTypes["MANY_TO_ONE"] = "MANY_TO_ONE";
1611
- })(RelationTypes || (RelationTypes = {}));
1612
-
1238
+ return RelationTypes;
1239
+ }(RelationTypes || {});
1613
1240
  var Relation = /*#__PURE__*/function () {
1614
1241
  /**
1615
1242
  * @param {RelationTypes} type the type of relation
@@ -1619,24 +1246,17 @@
1619
1246
  */
1620
1247
  function Relation(type, targetMetadataKey, serializedKey) {
1621
1248
  var attributeName = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
1622
-
1623
1249
  _classCallCheck(this, Relation);
1624
-
1625
1250
  _defineProperty(this, "type", void 0);
1626
-
1627
1251
  _defineProperty(this, "targetMetadataKey", void 0);
1628
-
1629
1252
  _defineProperty(this, "serializedKey", void 0);
1630
-
1631
1253
  _defineProperty(this, "attributeName", void 0);
1632
-
1633
1254
  this.type = type;
1634
1255
  this.targetMetadataKey = targetMetadataKey;
1635
1256
  this.serializedKey = serializedKey;
1636
1257
  this.attributeName = attributeName || this.serializedKey;
1637
1258
  }
1638
-
1639
- _createClass(Relation, [{
1259
+ return _createClass(Relation, [{
1640
1260
  key: "isOneToOne",
1641
1261
  value: function isOneToOne() {
1642
1262
  return this.type === Relation.ONE_TO_ONE;
@@ -1667,16 +1287,10 @@
1667
1287
  return this.isManyToOne() || this.isOneToOne();
1668
1288
  }
1669
1289
  }]);
1670
-
1671
- return Relation;
1672
1290
  }();
1673
-
1674
1291
  _defineProperty(Relation, "ONE_TO_ONE", RelationTypes.ONE_TO_ONE);
1675
-
1676
1292
  _defineProperty(Relation, "ONE_TO_MANY", RelationTypes.ONE_TO_MANY);
1677
-
1678
1293
  _defineProperty(Relation, "MANY_TO_ONE", RelationTypes.MANY_TO_ONE);
1679
-
1680
1294
  _defineProperty(Relation, "MANY_TO_MANY", RelationTypes.MANY_TO_MANY);
1681
1295
 
1682
1296
  /* eslint-disable */
@@ -1689,6 +1303,7 @@
1689
1303
  * This source code is licensed under the MIT license found in the
1690
1304
  * LICENSE file in the root directory of this source tree.
1691
1305
  */
1306
+
1692
1307
  var IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';
1693
1308
  var IS_RECORD_SENTINEL = '@@__IMMUTABLE_RECORD__@@';
1694
1309
  function isImmutable(maybeImmutable) {
@@ -1708,112 +1323,87 @@
1708
1323
  var result = diff(left, right);
1709
1324
  return result ? result.length > 0 : false;
1710
1325
  }
1326
+
1711
1327
  /**
1712
1328
  * get the id of an entity or return itself if string
1713
1329
  */
1714
-
1715
-
1716
1330
  function getEntityId(stringOrEntity, idSerializedKey) {
1717
1331
  if (_typeof(stringOrEntity) !== 'object') {
1718
1332
  return stringOrEntity;
1719
- } // eslint-disable-next-line @typescript-eslint/ban-ts-comment
1720
- // @ts-ignore
1721
-
1333
+ }
1722
1334
 
1335
+ // eslint-disable-next-line @typescript-eslint/ban-ts-comment
1336
+ // @ts-ignore
1723
1337
  return stringOrEntity[idSerializedKey];
1724
1338
  }
1339
+
1725
1340
  /**
1726
1341
  * find old relation value from the new relation id
1727
1342
  * if not found, returs the default serilazed model
1728
1343
  */
1729
-
1730
-
1731
1344
  function findOldRelation(newRelationValue, oldRelationValue, classMetadata) {
1732
- var idSerializedKey = classMetadata.getIdentifierAttribute().serializedKey; // eslint-disable-next-line @typescript-eslint/ban-ts-comment
1345
+ var idSerializedKey = classMetadata.getIdentifierAttribute().serializedKey;
1346
+ // eslint-disable-next-line @typescript-eslint/ban-ts-comment
1733
1347
  // @ts-ignore
1734
-
1735
1348
  var relationValueId = getEntityId(newRelationValue, idSerializedKey);
1736
1349
  var foundValue = oldRelationValue && oldRelationValue.find(function (innerOldRelationValue) {
1737
1350
  var oldRelationValueId = getEntityId(innerOldRelationValue, idSerializedKey);
1738
1351
  return relationValueId === oldRelationValueId;
1739
1352
  });
1740
-
1741
1353
  if (foundValue) {
1742
1354
  return foundValue;
1743
1355
  }
1744
-
1745
1356
  return classMetadata.getDefaultSerializedModel();
1746
1357
  }
1358
+
1747
1359
  /**
1748
1360
  * add all identifier from one to many relation list
1749
1361
  */
1750
-
1751
-
1752
1362
  function getIdentifierForList(newValue, idSerializedKey) {
1753
1363
  return newValue.map(function (value) {
1754
1364
  if (Object.keys(value).includes(idSerializedKey)) {
1755
1365
  return _defineProperty({}, idSerializedKey, value[idSerializedKey]);
1756
1366
  }
1757
-
1758
1367
  if (typeof value === 'string') {
1759
1368
  return value;
1760
1369
  }
1761
-
1762
1370
  throw new TypeError('new value should include a list of string or objects containing the serialized key');
1763
1371
  });
1764
1372
  }
1765
-
1766
- var _storage = new WeakMap();
1767
-
1768
- var _enabled = new WeakMap();
1769
-
1373
+ var _storage = /*#__PURE__*/new WeakMap();
1374
+ var _enabled = /*#__PURE__*/new WeakMap();
1770
1375
  var UnitOfWork = /*#__PURE__*/function () {
1771
1376
  function UnitOfWork(mapping) {
1772
1377
  var enabled = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
1773
-
1774
1378
  _classCallCheck(this, UnitOfWork);
1775
-
1776
1379
  _defineProperty(this, "mapping", void 0);
1777
-
1778
- _storage.set(this, {
1779
- writable: true,
1780
- value: void 0
1781
- });
1782
-
1783
- _enabled.set(this, {
1784
- writable: true,
1785
- value: void 0
1786
- });
1787
-
1380
+ _classPrivateFieldInitSpec(this, _storage, void 0);
1381
+ _classPrivateFieldInitSpec(this, _enabled, void 0);
1788
1382
  this.mapping = mapping;
1789
-
1790
- _classPrivateFieldSet(this, _enabled, enabled);
1791
-
1792
- _classPrivateFieldSet(this, _storage, {});
1383
+ _classPrivateFieldSet2(_enabled, this, enabled);
1384
+ _classPrivateFieldSet2(_storage, this, {});
1793
1385
  }
1794
-
1795
- _createClass(UnitOfWork, [{
1386
+ return _createClass(UnitOfWork, [{
1796
1387
  key: "registerClean",
1797
1388
  value: function registerClean(id, entity) {
1798
- if (!_classPrivateFieldGet(this, _enabled)) {
1389
+ if (!_classPrivateFieldGet2(_enabled, this)) {
1799
1390
  return;
1800
1391
  }
1801
-
1802
1392
  if (isImmutable(entity)) {
1803
- _classPrivateFieldGet(this, _storage)[id] = entity;
1393
+ _classPrivateFieldGet2(_storage, this)[id] = entity;
1804
1394
  } else {
1805
- _classPrivateFieldGet(this, _storage)[id] = _objectSpread2({}, entity);
1395
+ _classPrivateFieldGet2(_storage, this)[id] = _objectSpread2({}, entity);
1806
1396
  }
1807
1397
  }
1808
1398
  }, {
1809
1399
  key: "getDirtyEntity",
1810
1400
  value: function getDirtyEntity(id) {
1811
- return _classPrivateFieldGet(this, _storage)[id];
1401
+ return _classPrivateFieldGet2(_storage, this)[id];
1812
1402
  }
1813
1403
  }, {
1814
1404
  key: "clear",
1815
1405
  value: function clear(id) {
1816
- delete _classPrivateFieldGet(this, _storage)[id];
1406
+ delete _classPrivateFieldGet2(_storage, this)[id];
1817
1407
  }
1818
1408
  }, {
1819
1409
  key: "getDirtyData",
@@ -1824,7 +1414,6 @@
1824
1414
  key: "_getDirtyFieldsForAttribute",
1825
1415
  value: function _getDirtyFieldsForAttribute(dirtyFieldsParam, key, attribute, oldValue, newValue) {
1826
1416
  var dirtyFields = dirtyFieldsParam;
1827
-
1828
1417
  if (attribute.type === 'object' || attribute.type === 'array') {
1829
1418
  if (oldValue === undefined || objectDiffers(oldValue, newValue)) {
1830
1419
  dirtyFields[key] = newValue;
@@ -1832,71 +1421,58 @@
1832
1421
  } else if (oldValue !== newValue) {
1833
1422
  dirtyFields[key] = newValue;
1834
1423
  }
1835
-
1836
1424
  return dirtyFields;
1837
1425
  }
1838
1426
  }, {
1839
1427
  key: "_getDirtyFieldsForManyToOne",
1840
1428
  value: function _getDirtyFieldsForManyToOne(dirtyFieldsParam, key, oldValue, newValue, relationMetadata, idSerializedKey) {
1841
1429
  var dirtyFields = dirtyFieldsParam;
1842
-
1843
1430
  if (oldValue !== newValue) {
1844
1431
  if (newValue === null) {
1845
1432
  dirtyFields[key] = null;
1846
1433
  return dirtyFields;
1847
1434
  }
1848
-
1849
1435
  if (typeof oldValue === 'string' || typeof newValue === 'string') {
1850
1436
  dirtyFields[key] = newValue;
1851
1437
  }
1852
-
1853
1438
  var recursiveDiff = this._getDirtyFields(newValue, oldValue, relationMetadata);
1854
-
1855
1439
  if (Object.keys(recursiveDiff).length > 0) {
1856
1440
  recursiveDiff[idSerializedKey] = getEntityId(newValue, idSerializedKey);
1857
1441
  dirtyFields[key] = recursiveDiff;
1858
1442
  }
1859
1443
  }
1860
-
1861
1444
  return dirtyFields;
1862
1445
  }
1863
1446
  }, {
1864
1447
  key: "_getDirtyFieldsForOneToMany",
1865
1448
  value: function _getDirtyFieldsForOneToMany(dirtyFieldsParam, key, idSerializedKey, relationMetadata, oldValue, newValue) {
1866
1449
  var _this = this;
1867
-
1868
1450
  var dirtyFields = dirtyFieldsParam;
1869
1451
  var newValueLength = newValue ? newValue.length : 0;
1870
- var oldValueLength = oldValue ? oldValue.length : 0; // number of items changed
1452
+ var oldValueLength = oldValue ? oldValue.length : 0;
1871
1453
 
1454
+ // number of items changed
1872
1455
  if (newValueLength !== oldValueLength) {
1873
1456
  dirtyFields[key] = getIdentifierForList(newValue, idSerializedKey);
1874
1457
  }
1875
-
1876
1458
  if (newValue && newValue.length > 0) {
1877
1459
  if (dirtyFields[key] === undefined) {
1878
1460
  dirtyFields[key] = [];
1879
1461
  }
1880
-
1881
1462
  var relationList = newValue;
1882
1463
  relationList.forEach(function (newRelationValue, relationAttributeName) {
1883
1464
  var oldRelationValue = findOldRelation(newRelationValue, oldValue, relationMetadata);
1884
-
1885
1465
  if (newRelationValue !== oldRelationValue) {
1886
1466
  if (typeof newRelationValue === 'string' || typeof oldRelationValue === 'string') {
1887
1467
  dirtyFields[key][relationAttributeName] = newRelationValue;
1888
1468
  return;
1889
1469
  }
1890
-
1891
1470
  var recursiveDiff = _this._getDirtyFields(newRelationValue, oldRelationValue, relationMetadata);
1892
-
1893
1471
  if (Object.keys(recursiveDiff).length > 0) {
1894
1472
  var entityId = getEntityId(newRelationValue, idSerializedKey);
1895
-
1896
1473
  if (entityId !== null) {
1897
1474
  recursiveDiff[idSerializedKey] = entityId;
1898
1475
  }
1899
-
1900
1476
  if (dirtyFields[key][relationAttributeName]) {
1901
1477
  Object.assign(dirtyFields[key][relationAttributeName], recursiveDiff);
1902
1478
  } else {
@@ -1905,7 +1481,6 @@
1905
1481
  }
1906
1482
  }
1907
1483
  });
1908
-
1909
1484
  if (dirtyFields[key].length > 0) {
1910
1485
  // add identifier because one or more object linked has been updated
1911
1486
  // see test: 'get dirty data many to one update item'
@@ -1915,52 +1490,45 @@
1915
1490
  delete dirtyFields[key];
1916
1491
  }
1917
1492
  }
1918
-
1919
1493
  return dirtyFields;
1920
1494
  }
1921
1495
  }, {
1922
1496
  key: "_getDirtyFields",
1923
1497
  value: function _getDirtyFields(newSerializedModel, oldSerializedModel, classMetadata) {
1924
1498
  var _this2 = this;
1925
-
1926
1499
  var dirtyFields = {};
1927
1500
  Object.values(classMetadata.getAttributeList()).forEach(function (attribute) {
1928
1501
  var key = attribute.attributeName;
1929
1502
  var newValue = newSerializedModel[key];
1930
1503
  var oldValue = oldSerializedModel ? oldSerializedModel[key] : null;
1931
1504
  var currentRelation = classMetadata.getRelation(attribute.serializedKey);
1932
-
1933
1505
  if (newValue === undefined) {
1934
1506
  return;
1935
- } // not a relation
1936
-
1507
+ }
1937
1508
 
1509
+ // not a relation
1938
1510
  if (!currentRelation) {
1939
1511
  dirtyFields = _this2._getDirtyFieldsForAttribute(dirtyFields, key, attribute, oldValue, newValue);
1940
1512
  return;
1941
1513
  }
1942
-
1943
1514
  var relationMetadata = _this2.mapping.getClassMetadataByKey(currentRelation.targetMetadataKey);
1944
-
1945
1515
  if (!relationMetadata) {
1946
1516
  throw new TypeError("relation metadata is not set for relation ".concat(classMetadata.key, ".").concat(currentRelation.targetMetadataKey));
1947
1517
  }
1518
+ var idSerializedKey = relationMetadata.getIdentifierAttribute().serializedKey;
1948
1519
 
1949
- var idSerializedKey = relationMetadata.getIdentifierAttribute().serializedKey; // MANY_TO_ONE relation
1950
-
1520
+ // MANY_TO_ONE relation
1951
1521
  if (currentRelation.isRelationToOne()) {
1952
1522
  dirtyFields = _this2._getDirtyFieldsForManyToOne(dirtyFields, key, oldValue, newValue, relationMetadata, idSerializedKey);
1953
1523
  return;
1954
- } // *_TO_MANY relation
1955
-
1524
+ }
1956
1525
 
1526
+ // *_TO_MANY relation
1957
1527
  dirtyFields = _this2._getDirtyFieldsForOneToMany(dirtyFields, key, idSerializedKey, relationMetadata, oldValue, newValue);
1958
1528
  });
1959
1529
  return dirtyFields;
1960
1530
  }
1961
1531
  }]);
1962
-
1963
- return UnitOfWork;
1964
1532
  }();
1965
1533
 
1966
1534
  /* eslint-disable @typescript-eslint/no-unused-vars */
@@ -1968,44 +1536,44 @@
1968
1536
  function Serializer() {
1969
1537
  _classCallCheck(this, Serializer);
1970
1538
  }
1971
-
1972
- _createClass(Serializer, [{
1539
+ return _createClass(Serializer, [{
1973
1540
  key: "normalizeItem",
1974
-
1541
+ value:
1975
1542
  /**
1976
1543
  * convert an entity to a plain javascript object
1977
1544
  * @param {object} entity - The entity to convert
1978
1545
  * @param {ClassMetadata} classMetadata - the class metadata
1979
1546
  * @return {object} the object to serialize
1980
1547
  */
1981
- value: function normalizeItem(entity, classMetadata) {
1548
+ function normalizeItem(entity, classMetadata) {
1982
1549
  return entity;
1983
1550
  }
1551
+
1984
1552
  /**
1985
1553
  * convert a plain javascript object to string
1986
1554
  * @param {object} object - The object to convert to convert
1987
1555
  * @param {ClassMetadata} classMetadata - the class metadata
1988
1556
  * @return {string} the content of the request
1989
1557
  */
1990
-
1991
1558
  }, {
1992
1559
  key: "encodeItem",
1993
1560
  value: function encodeItem(object, classMetadata) {
1994
1561
  throw new TypeError('`encodeItem` method must be implemented');
1995
1562
  }
1563
+
1996
1564
  /**
1997
1565
  * convert an entity to string that will be sent as the request content
1998
1566
  * @param {any} entity - The entity to convert
1999
1567
  * @param {ClassMetadata} classMetadata - the class metadata
2000
1568
  * @return {string} the content of the request
2001
1569
  */
2002
-
2003
1570
  }, {
2004
1571
  key: "serializeItem",
2005
1572
  value: function serializeItem(object, classMetadata) {
2006
1573
  var noralizedData = this.normalizeItem(object, classMetadata);
2007
1574
  return this.encodeItem(noralizedData, classMetadata);
2008
1575
  }
1576
+
2009
1577
  /**
2010
1578
  * convert a plain object to an entity
2011
1579
  * @param {object} object - The plain javascript object
@@ -2013,12 +1581,12 @@
2013
1581
  * @param {Record<string, unknown>} response - the HTTP response
2014
1582
  * @return {object} an entity
2015
1583
  */
2016
-
2017
1584
  }, {
2018
1585
  key: "denormalizeItem",
2019
1586
  value: function denormalizeItem(object, classMetadata, response) {
2020
1587
  return object;
2021
1588
  }
1589
+
2022
1590
  /**
2023
1591
  * convert a string containing an object to a plain javascript object
2024
1592
  * @param {string} rawData - The string fetched from the response
@@ -2026,12 +1594,12 @@
2026
1594
  * @param {Record<string, unknown>} response - the HTTP response
2027
1595
  * @return {object} the normalized object
2028
1596
  */
2029
-
2030
1597
  }, {
2031
1598
  key: "decodeItem",
2032
1599
  value: function decodeItem(rawData, classMetadata, response) {
2033
1600
  throw new TypeError('`decodeItem` method must be implemented');
2034
1601
  }
1602
+
2035
1603
  /**
2036
1604
  * convert a string containing an object to an entity
2037
1605
  * @param {string} rawData - The string fetched from the response
@@ -2039,13 +1607,13 @@
2039
1607
  * @param {Record<string, unknown>} response - the HTTP response
2040
1608
  * @return {object} the entity
2041
1609
  */
2042
-
2043
1610
  }, {
2044
1611
  key: "deserializeItem",
2045
1612
  value: function deserializeItem(rawData, classMetadata, response) {
2046
1613
  var object = this.decodeItem(rawData, classMetadata, response);
2047
1614
  return this.denormalizeItem(object, classMetadata, response);
2048
1615
  }
1616
+
2049
1617
  /**
2050
1618
  * convert a plain object list to an entity list
2051
1619
  * @param {Iterable<object>} objectList - The plain javascript object list (or an iterable object)
@@ -2053,12 +1621,12 @@
2053
1621
  * @param {Record<string, unknown>} response - the HTTP response
2054
1622
  * @return {Iterable<object>} a list of entities
2055
1623
  */
2056
-
2057
1624
  }, {
2058
1625
  key: "denormalizeList",
2059
1626
  value: function denormalizeList(objectList, classMetadata, response) {
2060
1627
  return objectList; // weird conversion as the declaration of list type is fuzzy
2061
1628
  }
1629
+
2062
1630
  /**
2063
1631
  * convert a string containing a list of objects to a list of plain javascript objects
2064
1632
  * @param {string} rawListData - The string fetched from the response
@@ -2066,12 +1634,12 @@
2066
1634
  * @param {Record<string, unknown>} response - the HTTP response
2067
1635
  * @return {Iterable<object>} a list of normalized objects
2068
1636
  */
2069
-
2070
1637
  }, {
2071
1638
  key: "decodeList",
2072
1639
  value: function decodeList(rawListData, classMetadata, response) {
2073
1640
  throw new TypeError('`deserializeList` method must be implemented');
2074
1641
  }
1642
+
2075
1643
  /**
2076
1644
  * convert a string containing a list of objects to a list of entities
2077
1645
  * @param {string} rawListData - The string fetched from the response
@@ -2079,7 +1647,6 @@
2079
1647
  * @param {Record<string, unknown>} response - the HTTP response
2080
1648
  * @return {Iterable<object>} a list of entities
2081
1649
  */
2082
-
2083
1650
  }, {
2084
1651
  key: "deserializeList",
2085
1652
  value: function deserializeList(rawListData, classMetadata, response) {
@@ -2087,22 +1654,15 @@
2087
1654
  return this.denormalizeList(objectList, classMetadata, response);
2088
1655
  }
2089
1656
  }]);
2090
-
2091
- return Serializer;
2092
1657
  }();
2093
1658
 
2094
1659
  var JsSerializer = /*#__PURE__*/function (_Serializer) {
2095
- _inherits(JsSerializer, _Serializer);
2096
-
2097
- var _super = _createSuper(JsSerializer);
2098
-
2099
1660
  function JsSerializer() {
2100
1661
  _classCallCheck(this, JsSerializer);
2101
-
2102
- return _super.apply(this, arguments);
1662
+ return _callSuper(this, JsSerializer, arguments);
2103
1663
  }
2104
-
2105
- _createClass(JsSerializer, [{
1664
+ _inherits(JsSerializer, _Serializer);
1665
+ return _createClass(JsSerializer, [{
2106
1666
  key: "encodeItem",
2107
1667
  value: function encodeItem(object, classMetadata) {
2108
1668
  return JSON.stringify(object);
@@ -2118,66 +1678,60 @@
2118
1678
  return JSON.parse(rawListData);
2119
1679
  }
2120
1680
  }]);
2121
-
2122
- return JsSerializer;
2123
1681
  }(Serializer);
2124
1682
 
2125
1683
  function levenshteinDistance(a, b) {
2126
- var matrix = []; // Increment along the first column of each row
1684
+ var matrix = [];
2127
1685
 
1686
+ // Increment along the first column of each row
2128
1687
  for (var i = 0; i <= b.length; i += 1) {
2129
1688
  matrix[i] = [i];
2130
- } // Increment each column in the first row
2131
-
1689
+ }
2132
1690
 
1691
+ // Increment each column in the first row
2133
1692
  for (var j = 0; j <= a.length; j += 1) {
2134
1693
  matrix[0][j] = j;
2135
- } // Fill in the rest of the matrix
2136
-
1694
+ }
2137
1695
 
1696
+ // Fill in the rest of the matrix
2138
1697
  for (var _i = 1; _i <= b.length; _i += 1) {
2139
1698
  for (var _j = 1; _j <= a.length; _j += 1) {
2140
1699
  if (b.charAt(_i - 1) === a.charAt(_j - 1)) {
2141
1700
  matrix[_i][_j] = matrix[_i - 1][_j - 1];
2142
1701
  } else {
2143
- matrix[_i][_j] = Math.min(matrix[_i - 1][_j - 1] + 1, // substitution
2144
- matrix[_i][_j - 1] + 1, // insertion
1702
+ matrix[_i][_j] = Math.min(matrix[_i - 1][_j - 1] + 1,
1703
+ // substitution
1704
+ matrix[_i][_j - 1] + 1,
1705
+ // insertion
2145
1706
  matrix[_i - 1][_j] + 1 // deletion
2146
1707
  );
2147
1708
  }
2148
1709
  }
2149
1710
  }
2150
-
2151
1711
  return matrix[b.length][a.length];
2152
- } // eslint-disable-next-line import/prefer-default-export
2153
-
2154
-
1712
+ }
2155
1713
  function findClosestWord(word, list) {
2156
1714
  var maxDistance = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Infinity;
2157
1715
  var closestWord = null;
2158
- var minDistance = Infinity; // eslint-disable-next-line no-plusplus
2159
-
1716
+ var minDistance = Infinity;
2160
1717
  for (var i = 0; i < list.length; i += 1) {
2161
1718
  var candidate = list[i];
2162
1719
  var distance = levenshteinDistance(word, candidate);
2163
-
2164
1720
  if (distance < minDistance && distance <= maxDistance) {
2165
1721
  minDistance = distance;
2166
1722
  closestWord = candidate;
2167
1723
  }
2168
1724
  }
2169
-
2170
1725
  return closestWord;
2171
1726
  }
2172
1727
 
1728
+ // type SdkResponse = Partial<Response>;
1729
+
2173
1730
  var generateId = function generateId() {
2174
1731
  return "rest-client-sdk|".concat(Date.now(), "-").concat(Math.floor(Math.random() * (9e12 - 1)) + 1e12);
2175
1732
  };
2176
-
2177
1733
  function serializeRequest(req) {
2178
1734
  var request = _objectSpread2({}, req); // Make a clone, useful for doing destructive things
2179
-
2180
-
2181
1735
  return {
2182
1736
  method: request.method,
2183
1737
  // The Request Method, e.g. GET, POST, DELETE
@@ -2186,31 +1740,20 @@
2186
1740
  headers: request.headers ? convertToRecord(request.headers) : undefined,
2187
1741
  body: typeof request.body === 'string' ? request.body : undefined
2188
1742
  };
2189
- } // eslint-disable-next-line import/prefer-default-export
2190
-
2191
-
2192
- var _history = new WeakMap();
2193
-
1743
+ }
1744
+ var _history = /*#__PURE__*/new WeakMap();
2194
1745
  var Logger = /*#__PURE__*/function () {
2195
- _createClass(Logger, [{
2196
- key: "history",
2197
- get: function get() {
2198
- return _classPrivateFieldGet(this, _history);
2199
- }
2200
- }]);
2201
-
2202
1746
  function Logger() {
2203
1747
  _classCallCheck(this, Logger);
2204
-
2205
- _history.set(this, {
2206
- writable: true,
2207
- value: void 0
2208
- });
2209
-
2210
- _classPrivateFieldSet(this, _history, []);
1748
+ _classPrivateFieldInitSpec(this, _history, void 0);
1749
+ _classPrivateFieldSet2(_history, this, []);
2211
1750
  }
2212
-
2213
- _createClass(Logger, [{
1751
+ return _createClass(Logger, [{
1752
+ key: "history",
1753
+ get: function get() {
1754
+ return _classPrivateFieldGet2(_history, this);
1755
+ }
1756
+ }, {
2214
1757
  key: "logRequest",
2215
1758
  value: function logRequest(params) {
2216
1759
  var log = {
@@ -2220,15 +1763,15 @@
2220
1763
  request: Date.now()
2221
1764
  }
2222
1765
  };
2223
-
2224
- _classPrivateFieldGet(this, _history).push(log);
2225
-
1766
+ _classPrivateFieldGet2(_history, this).push(log);
2226
1767
  return log.id;
2227
1768
  }
2228
1769
  }, {
2229
1770
  key: "logResponse",
2230
1771
  value: function logResponse(response, requestId) {
2231
- var id = requestId || generateId(); // console.log('clone');
1772
+ var id = requestId || generateId();
1773
+
1774
+ // console.log('clone');
2232
1775
  // const clonedResponse = response.clone(); // THIS IS THE LINE THAT CAUSES THE PROBLEM
2233
1776
  // console.log('after clone', clonedResponse.status);
2234
1777
 
@@ -2237,16 +1780,14 @@
2237
1780
  // clonedResponse.status,
2238
1781
  headers: Object.fromEntries(response.headers)
2239
1782
  };
2240
-
2241
- var foundLogIndex = _classPrivateFieldGet(this, _history).findIndex(function (log) {
1783
+ var foundLogIndex = _classPrivateFieldGet2(_history, this).findIndex(function (log) {
2242
1784
  return log.id === id;
2243
1785
  });
2244
-
2245
1786
  if (foundLogIndex > -1) {
2246
- _classPrivateFieldGet(this, _history)[foundLogIndex].response = logContent;
2247
- _classPrivateFieldGet(this, _history)[foundLogIndex].logTimes.response = Date.now();
1787
+ _classPrivateFieldGet2(_history, this)[foundLogIndex].response = logContent;
1788
+ _classPrivateFieldGet2(_history, this)[foundLogIndex].logTimes.response = Date.now();
2248
1789
  } else {
2249
- _classPrivateFieldGet(this, _history).push({
1790
+ _classPrivateFieldGet2(_history, this).push({
2250
1791
  id: id,
2251
1792
  response: logContent,
2252
1793
  logTimes: {
@@ -2254,82 +1795,59 @@
2254
1795
  }
2255
1796
  });
2256
1797
  }
2257
-
2258
1798
  return id;
2259
1799
  }
2260
1800
  }]);
2261
-
2262
- return Logger;
2263
1801
  }();
2264
1802
 
2265
- var _repositoryList = new WeakMap();
1803
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
2266
1804
 
1805
+ // export type SdkMetadata = Record<string, [any, Iterable<any>, undefined | any]>;
1806
+ var _repositoryList = /*#__PURE__*/new WeakMap();
2267
1807
  var RestClientSdk = /*#__PURE__*/function () {
2268
1808
  function RestClientSdk(tokenStorage, config, mapping) {
2269
1809
  var serializer = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : new JsSerializer();
2270
-
2271
1810
  _classCallCheck(this, RestClientSdk);
2272
-
2273
1811
  _defineProperty(this, "config", void 0);
2274
-
2275
1812
  _defineProperty(this, "tokenStorage", void 0);
2276
-
2277
1813
  _defineProperty(this, "serializer", void 0);
2278
-
2279
1814
  _defineProperty(this, "mapping", void 0);
2280
-
2281
1815
  _defineProperty(this, "unitOfWork", void 0);
2282
-
2283
- _repositoryList.set(this, {
2284
- writable: true,
2285
- value: void 0
2286
- });
2287
-
1816
+ _classPrivateFieldInitSpec(this, _repositoryList, void 0);
2288
1817
  _defineProperty(this, "logger", void 0);
2289
-
2290
1818
  this.checkConfigValidity(config);
2291
-
2292
1819
  if (!(mapping instanceof Mapping)) {
2293
1820
  throw new TypeError('mapping should be an instance of `Mapping`');
2294
1821
  }
2295
-
2296
1822
  this.config = this._mergeWithBaseConfig(config);
2297
1823
  this.tokenStorage = tokenStorage;
2298
1824
  this.serializer = serializer;
2299
1825
  this.mapping = mapping;
2300
1826
  this.unitOfWork = new UnitOfWork(this.mapping, this.config.unitOfWorkEnabled);
2301
-
2302
1827
  if (config.loggerEnabled) {
2303
1828
  this.logger = new Logger();
2304
1829
  }
2305
-
2306
- _classPrivateFieldSet(this, _repositoryList, {});
1830
+ _classPrivateFieldSet2(_repositoryList, this, {});
2307
1831
  }
1832
+
2308
1833
  /**
2309
1834
  * get a repository by it's metadata "key" attribute
2310
1835
  *
2311
1836
  * @param {string} key the repository "key" (the first argument of `new ClassMetadata`)
2312
1837
  */
2313
-
2314
-
2315
- _createClass(RestClientSdk, [{
1838
+ return _createClass(RestClientSdk, [{
2316
1839
  key: "getRepository",
2317
1840
  value: function getRepository(key) {
2318
- if (!_classPrivateFieldGet(this, _repositoryList)[key]) {
1841
+ if (!_classPrivateFieldGet2(_repositoryList, this)[key]) {
2319
1842
  var metadata = this.mapping.getClassMetadataByKey(key);
2320
-
2321
1843
  if (!metadata) {
2322
1844
  var closeKey = findClosestWord(key, this.mapping.getMappingKeys(), 5);
2323
1845
  var suggestions = closeKey ? " Did you mean \"".concat(closeKey, "\"?") : '';
2324
1846
  throw new Error("Unable to get metadata for repository \"".concat(key, "\".").concat(suggestions));
2325
- } // eslint-disable-next-line new-cap
2326
-
2327
-
2328
- _classPrivateFieldGet(this, _repositoryList)[key] = generateRepository(this, metadata, this.config.unitOfWorkEnabled);
2329
- } // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
2330
-
2331
-
2332
- return _classPrivateFieldGet(this, _repositoryList)[key];
1847
+ }
1848
+ _classPrivateFieldGet2(_repositoryList, this)[key] = generateRepository(this, metadata, this.config.unitOfWorkEnabled);
1849
+ }
1850
+ return _classPrivateFieldGet2(_repositoryList, this)[key];
2333
1851
  }
2334
1852
  }, {
2335
1853
  key: "_mergeWithBaseConfig",
@@ -2347,49 +1865,37 @@
2347
1865
  }
2348
1866
  }
2349
1867
  }]);
2350
-
2351
- return RestClientSdk;
2352
1868
  }();
2353
1869
 
2354
1870
  var AbstractTokenGenerator = /*#__PURE__*/function () {
2355
1871
  function AbstractTokenGenerator(tokenGeneratorConfig, logger) {
2356
1872
  _classCallCheck(this, AbstractTokenGenerator);
2357
-
2358
1873
  _defineProperty(this, "tokenGeneratorConfig", void 0);
2359
-
2360
1874
  _defineProperty(this, "logger", void 0);
2361
-
2362
1875
  if (logger) {
2363
1876
  this.logger = logger;
2364
1877
  }
2365
-
2366
1878
  this.tokenGeneratorConfig = tokenGeneratorConfig;
2367
-
2368
1879
  if (typeof this.checkTokenGeneratorConfig === 'function') {
2369
1880
  this.checkTokenGeneratorConfig(this.tokenGeneratorConfig);
2370
1881
  }
2371
1882
  }
2372
-
2373
- _createClass(AbstractTokenGenerator, [{
1883
+ return _createClass(AbstractTokenGenerator, [{
2374
1884
  key: "_manageOauthError",
2375
-
2376
- /** @deprecated */
2377
- value: function _manageOauthError(response) {
1885
+ value: /** @deprecated */
1886
+ function _manageOauthError(response) {
2378
1887
  return response.clone().json().then(function (body) {
2379
1888
  if (body.error === 'invalid_grant') {
2380
1889
  throw new InvalidGrantError(body.error, getHttpErrorFromResponse(response));
2381
1890
  }
2382
-
2383
1891
  if (body.error === 'invalid_scope') {
2384
1892
  throw new InvalidScopeError(body.error, getHttpErrorFromResponse(response));
2385
1893
  }
2386
-
2387
1894
  throw new OauthError(body.error, getHttpErrorFromResponse(response));
2388
1895
  })["catch"](function (err) {
2389
1896
  if (!(err instanceof OauthError)) {
2390
1897
  throw new OauthError(err.type, getHttpErrorFromResponse(response));
2391
1898
  }
2392
-
2393
1899
  throw err;
2394
1900
  });
2395
1901
  }
@@ -2397,16 +1903,12 @@
2397
1903
  key: "generateUrlFromConfig",
2398
1904
  value: function generateUrlFromConfig(config) {
2399
1905
  var uri = new URI("".concat(config.scheme, "://").concat(config.path));
2400
-
2401
1906
  if (config.port) {
2402
1907
  uri.port(config.port);
2403
1908
  }
2404
-
2405
1909
  return uri.toString();
2406
1910
  }
2407
1911
  }]);
2408
-
2409
- return AbstractTokenGenerator;
2410
1912
  }();
2411
1913
 
2412
1914
  /**
@@ -2415,25 +1917,19 @@
2415
1917
  * @See {@link https://oauth2.thephpleague.com/authorization-server/auth-code-grant/|the great article of the PHP League} about authorization code flow.
2416
1918
  */
2417
1919
  var AuthorizationCodeFlowTokenGenerator = /*#__PURE__*/function (_AbstractTokenGenerat) {
2418
- _inherits(AuthorizationCodeFlowTokenGenerator, _AbstractTokenGenerat);
2419
-
2420
- var _super = _createSuper(AuthorizationCodeFlowTokenGenerator);
2421
-
2422
1920
  function AuthorizationCodeFlowTokenGenerator() {
2423
1921
  _classCallCheck(this, AuthorizationCodeFlowTokenGenerator);
2424
-
2425
- return _super.apply(this, arguments);
1922
+ return _callSuper(this, AuthorizationCodeFlowTokenGenerator, arguments);
2426
1923
  }
2427
-
2428
- _createClass(AuthorizationCodeFlowTokenGenerator, [{
1924
+ _inherits(AuthorizationCodeFlowTokenGenerator, _AbstractTokenGenerat);
1925
+ return _createClass(AuthorizationCodeFlowTokenGenerator, [{
2429
1926
  key: "generateToken",
2430
-
1927
+ value:
2431
1928
  /**
2432
1929
  * This function needs no generate an access token
2433
1930
  */
2434
- value: function generateToken(parameters) {
1931
+ function generateToken(parameters) {
2435
1932
  this._checkGenerateParameters(parameters);
2436
-
2437
1933
  var url = this.generateUrlFromConfig(this.tokenGeneratorConfig);
2438
1934
  var params = {
2439
1935
  method: 'POST',
@@ -2449,31 +1945,27 @@
2449
1945
  code: parameters.code
2450
1946
  }).toString()
2451
1947
  };
2452
-
2453
1948
  if (this.logger) {
2454
1949
  this.logger.logRequest(_objectSpread2({
2455
1950
  url: url
2456
1951
  }, params));
2457
1952
  }
2458
-
2459
1953
  return fetch(url, params);
2460
1954
  }
1955
+
2461
1956
  /**
2462
1957
  * This function needs to refresh the current possibly expired access token
2463
1958
  * and return a Promise that will be resolved with a fresh access token
2464
1959
  */
2465
-
2466
1960
  }, {
2467
1961
  key: "refreshToken",
2468
1962
  value: function refreshToken(oldAccessToken) {
2469
1963
  if (!oldAccessToken) {
2470
1964
  throw new Error('refresh_token is not set. Did you called `generateToken` before ?');
2471
1965
  }
2472
-
2473
- if (!(oldAccessToken === null || oldAccessToken === void 0 ? void 0 : oldAccessToken.refresh_token)) {
1966
+ if (!(oldAccessToken !== null && oldAccessToken !== void 0 && oldAccessToken.refresh_token)) {
2474
1967
  throw new Error('Unable to refreshToken as there are no refresh_token');
2475
1968
  }
2476
-
2477
1969
  var url = this.generateUrlFromConfig(this.tokenGeneratorConfig);
2478
1970
  var params = {
2479
1971
  method: 'POST',
@@ -2487,13 +1979,11 @@
2487
1979
  refresh_token: oldAccessToken.refresh_token
2488
1980
  }).toString()
2489
1981
  };
2490
-
2491
1982
  if (this.logger) {
2492
1983
  this.logger.logRequest(_objectSpread2({
2493
1984
  url: url
2494
1985
  }, params));
2495
1986
  }
2496
-
2497
1987
  return fetch(url, params);
2498
1988
  }
2499
1989
  }, {
@@ -2502,15 +1992,12 @@
2502
1992
  if (!config || Object.keys(config).length === 0) {
2503
1993
  throw new RangeError('TokenGenerator config must be set');
2504
1994
  }
2505
-
2506
1995
  if (!(config.path && config.scheme)) {
2507
1996
  throw new RangeError('TokenGenerator config is not valid, it should contain a "path", a "scheme" parameter');
2508
1997
  }
2509
-
2510
1998
  if (!(config.clientId && config.clientSecret)) {
2511
1999
  throw new RangeError('TokenGenerator config is not valid, it should contain a "clientId", a "clientSecret" parameter');
2512
2000
  }
2513
-
2514
2001
  if (!config.redirectUri) {
2515
2002
  throw new RangeError('TokenGenerator config is not valid, it should contain a "redirectUri" parameter');
2516
2003
  }
@@ -2521,43 +2008,36 @@
2521
2008
  if (!(parameters && Object.keys(parameters).length > 0)) {
2522
2009
  throw new RangeError('parameters must be set');
2523
2010
  }
2524
-
2525
2011
  if (!parameters.code) {
2526
2012
  throw new RangeError('"code" must be passed as parameter');
2527
2013
  }
2528
2014
  }
2529
2015
  }]);
2530
-
2531
- return AuthorizationCodeFlowTokenGenerator;
2532
2016
  }(AbstractTokenGenerator);
2533
2017
 
2534
- /* eslint-disable import/prefer-default-export */
2535
2018
  // memoize promise returning function so that it returns
2536
2019
  // the same promise if called again before resolve / reject
2020
+
2537
2021
  function memoizePromise(callback) {
2538
2022
  var cache = {};
2539
-
2540
2023
  function memoized() {
2541
2024
  for (var _len = arguments.length, parameters = new Array(_len), _key = 0; _key < _len; _key++) {
2542
2025
  parameters[_key] = arguments[_key];
2543
2026
  }
2544
-
2545
2027
  var cacheKey = JSON.stringify(parameters);
2546
2028
  var cacheValue = cache[cacheKey];
2547
-
2548
2029
  if (cacheValue) {
2549
2030
  return cacheValue;
2550
- } // Get and add the value to the cache
2551
-
2031
+ }
2552
2032
 
2033
+ // Get and add the value to the cache
2553
2034
  var value = callback.apply(this, parameters);
2554
2035
  cache[cacheKey] = value;
2555
-
2556
2036
  if (!value || typeof value.then !== 'function') {
2557
2037
  throw new Error('Memoization Error, Async function returned non-promise value');
2558
- } // Delete the value regardless of whether it resolves or rejects
2559
-
2038
+ }
2560
2039
 
2040
+ // Delete the value regardless of whether it resolves or rejects
2561
2041
  return value.then(function (internalValue) {
2562
2042
  cache[cacheKey] = false;
2563
2043
  return internalValue;
@@ -2566,31 +2046,23 @@
2566
2046
  throw err;
2567
2047
  });
2568
2048
  }
2569
-
2570
2049
  memoized.cache = cache;
2571
2050
  return memoized;
2572
2051
  }
2573
2052
 
2574
- var ERROR_CONFIG_EMPTY = 'TokenGenerator config must be set';
2575
- var ERROR_CONFIG_PATH_SCHEME = 'TokenGenerator config is not valid, it should contain a "path", a "scheme" parameter';
2576
- var ERROR_CONFIG_CLIENT_INFORMATIONS = 'TokenGenerator config is not valid, it should contain a "clientId", a "clientSecret" parameter';
2577
-
2053
+ var ERROR_CONFIG_EMPTY$1 = 'TokenGenerator config must be set';
2054
+ var ERROR_CONFIG_PATH_SCHEME$1 = 'TokenGenerator config is not valid, it should contain a "path", a "scheme" parameter';
2055
+ var ERROR_CONFIG_CLIENT_INFORMATIONS$1 = 'TokenGenerator config is not valid, it should contain a "clientId", a "clientSecret" parameter';
2578
2056
  var ClientCredentialsGenerator = /*#__PURE__*/function (_AbstractTokenGenerat) {
2579
- _inherits(ClientCredentialsGenerator, _AbstractTokenGenerat);
2580
-
2581
- var _super = _createSuper(ClientCredentialsGenerator);
2582
-
2583
2057
  function ClientCredentialsGenerator(tokenGeneratorConfig) {
2584
2058
  var _this;
2585
-
2586
2059
  _classCallCheck(this, ClientCredentialsGenerator);
2587
-
2588
- _this = _super.call(this, tokenGeneratorConfig);
2060
+ _this = _callSuper(this, ClientCredentialsGenerator, [tokenGeneratorConfig]);
2589
2061
  _this.generateToken = memoizePromise(_this.generateToken);
2590
2062
  return _this;
2591
2063
  }
2592
-
2593
- _createClass(ClientCredentialsGenerator, [{
2064
+ _inherits(ClientCredentialsGenerator, _AbstractTokenGenerat);
2065
+ return _createClass(ClientCredentialsGenerator, [{
2594
2066
  key: "generateToken",
2595
2067
  value: function generateToken() {
2596
2068
  var baseParameters = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
@@ -2599,13 +2071,11 @@
2599
2071
  client_id: this.tokenGeneratorConfig.clientId,
2600
2072
  client_secret: this.tokenGeneratorConfig.clientSecret
2601
2073
  });
2602
-
2603
2074
  if (baseParameters.scope) {
2604
2075
  body.append('scope', baseParameters.scope);
2605
2076
  } else if (this.tokenGeneratorConfig.scope) {
2606
2077
  body.append('scope', this.tokenGeneratorConfig.scope);
2607
2078
  }
2608
-
2609
2079
  var params = {
2610
2080
  method: 'POST',
2611
2081
  headers: {
@@ -2614,18 +2084,17 @@
2614
2084
  body: body.toString()
2615
2085
  };
2616
2086
  var url = this.generateUrlFromConfig(this.tokenGeneratorConfig);
2617
-
2618
2087
  if (this.logger) {
2619
2088
  this.logger.logRequest(_objectSpread2({
2620
2089
  url: url
2621
2090
  }, params));
2622
2091
  }
2623
-
2624
2092
  return fetch(url, params);
2625
2093
  }
2626
2094
  }, {
2627
2095
  key: "refreshToken",
2628
- value: function refreshToken( // eslint-disable-next-line @typescript-eslint/no-unused-vars
2096
+ value: function refreshToken(
2097
+ // eslint-disable-next-line @typescript-eslint/no-unused-vars
2629
2098
  accessToken) {
2630
2099
  return this.generateToken({});
2631
2100
  }
@@ -2633,44 +2102,33 @@
2633
2102
  key: "checkTokenGeneratorConfig",
2634
2103
  value: function checkTokenGeneratorConfig(config) {
2635
2104
  if (!config || Object.keys(config).length === 0) {
2636
- throw new RangeError(ERROR_CONFIG_EMPTY);
2105
+ throw new RangeError(ERROR_CONFIG_EMPTY$1);
2637
2106
  }
2638
-
2639
2107
  if (!(config.path && config.scheme)) {
2640
- throw new RangeError(ERROR_CONFIG_PATH_SCHEME);
2108
+ throw new RangeError(ERROR_CONFIG_PATH_SCHEME$1);
2641
2109
  }
2642
-
2643
2110
  if (!(config.clientId && config.clientSecret)) {
2644
- throw new RangeError(ERROR_CONFIG_CLIENT_INFORMATIONS);
2111
+ throw new RangeError(ERROR_CONFIG_CLIENT_INFORMATIONS$1);
2645
2112
  }
2646
2113
  }
2647
2114
  }]);
2648
-
2649
- return ClientCredentialsGenerator;
2650
2115
  }(AbstractTokenGenerator);
2651
2116
 
2652
- var ERROR_CONFIG_EMPTY$1 = 'TokenGenerator config must be set';
2653
- var ERROR_CONFIG_PATH_SCHEME$1 = 'TokenGenerator config is not valid, it should contain a "path", a "scheme" parameter';
2654
- var ERROR_CONFIG_CLIENT_INFORMATIONS$1 = 'TokenGenerator config is not valid, it should contain a "clientId", a "clientSecret" parameter';
2117
+ var ERROR_CONFIG_EMPTY = 'TokenGenerator config must be set';
2118
+ var ERROR_CONFIG_PATH_SCHEME = 'TokenGenerator config is not valid, it should contain a "path", a "scheme" parameter';
2119
+ var ERROR_CONFIG_CLIENT_INFORMATIONS = 'TokenGenerator config is not valid, it should contain a "clientId", a "clientSecret" parameter';
2655
2120
  var ERROR_TOKEN_EMPTY = 'parameters must be set';
2656
2121
  var ERROR_TOKEN_USERNAME_PASSWORD = 'username and password must be passed as parameters';
2657
-
2658
2122
  var PasswordGenerator = /*#__PURE__*/function (_AbstractTokenGenerat) {
2659
- _inherits(PasswordGenerator, _AbstractTokenGenerat);
2660
-
2661
- var _super = _createSuper(PasswordGenerator);
2662
-
2663
2123
  function PasswordGenerator() {
2664
2124
  _classCallCheck(this, PasswordGenerator);
2665
-
2666
- return _super.apply(this, arguments);
2125
+ return _callSuper(this, PasswordGenerator, arguments);
2667
2126
  }
2668
-
2669
- _createClass(PasswordGenerator, [{
2127
+ _inherits(PasswordGenerator, _AbstractTokenGenerat);
2128
+ return _createClass(PasswordGenerator, [{
2670
2129
  key: "generateToken",
2671
2130
  value: function generateToken(baseParameters) {
2672
2131
  this._checkGenerateParameters(baseParameters);
2673
-
2674
2132
  var body = new URLSearchParams({
2675
2133
  grant_type: 'password',
2676
2134
  username: baseParameters.username,
@@ -2678,13 +2136,11 @@
2678
2136
  client_id: this.tokenGeneratorConfig.clientId,
2679
2137
  client_secret: this.tokenGeneratorConfig.clientSecret
2680
2138
  });
2681
-
2682
2139
  if (baseParameters.scope) {
2683
2140
  body.append('scope', baseParameters.scope);
2684
2141
  } else if (this.tokenGeneratorConfig.scope) {
2685
2142
  body.append('scope', this.tokenGeneratorConfig.scope);
2686
2143
  }
2687
-
2688
2144
  var url = this.generateUrlFromConfig(this.tokenGeneratorConfig);
2689
2145
  var params = {
2690
2146
  method: 'POST',
@@ -2693,35 +2149,29 @@
2693
2149
  },
2694
2150
  body: body.toString()
2695
2151
  };
2696
-
2697
2152
  if (this.logger) {
2698
2153
  this.logger.logRequest(_objectSpread2({
2699
2154
  url: url
2700
2155
  }, params));
2701
2156
  }
2702
-
2703
2157
  return fetch(url, params);
2704
2158
  }
2705
2159
  }, {
2706
2160
  key: "refreshToken",
2707
2161
  value: function refreshToken(accessToken) {
2708
2162
  var refreshToken = accessToken === null || accessToken === void 0 ? void 0 : accessToken.refresh_token;
2709
-
2710
2163
  if (!refreshToken) {
2711
2164
  throw new Error('refresh_token is not set. Did you called `generateToken` before ?');
2712
2165
  }
2713
-
2714
2166
  var body = new URLSearchParams({
2715
2167
  grant_type: 'refresh_token',
2716
2168
  client_id: this.tokenGeneratorConfig.clientId,
2717
2169
  client_secret: this.tokenGeneratorConfig.clientSecret,
2718
2170
  refresh_token: refreshToken
2719
2171
  });
2720
-
2721
2172
  if (this.tokenGeneratorConfig.scope) {
2722
2173
  body.append('scope', this.tokenGeneratorConfig.scope);
2723
2174
  }
2724
-
2725
2175
  var url = this.generateUrlFromConfig(this.tokenGeneratorConfig);
2726
2176
  var params = {
2727
2177
  method: 'POST',
@@ -2730,28 +2180,24 @@
2730
2180
  },
2731
2181
  body: body.toString()
2732
2182
  };
2733
-
2734
2183
  if (this.logger) {
2735
2184
  this.logger.logRequest(_objectSpread2({
2736
2185
  url: url
2737
2186
  }, params));
2738
2187
  }
2739
-
2740
2188
  return fetch(url, params);
2741
2189
  }
2742
2190
  }, {
2743
2191
  key: "checkTokenGeneratorConfig",
2744
2192
  value: function checkTokenGeneratorConfig(config) {
2745
2193
  if (!config || Object.keys(config).length === 0) {
2746
- throw new RangeError(ERROR_CONFIG_EMPTY$1);
2194
+ throw new RangeError(ERROR_CONFIG_EMPTY);
2747
2195
  }
2748
-
2749
2196
  if (!(config.path && config.scheme)) {
2750
- throw new RangeError(ERROR_CONFIG_PATH_SCHEME$1);
2197
+ throw new RangeError(ERROR_CONFIG_PATH_SCHEME);
2751
2198
  }
2752
-
2753
2199
  if (!(config.clientId && config.clientSecret)) {
2754
- throw new RangeError(ERROR_CONFIG_CLIENT_INFORMATIONS$1);
2200
+ throw new RangeError(ERROR_CONFIG_CLIENT_INFORMATIONS);
2755
2201
  }
2756
2202
  }
2757
2203
  }, {
@@ -2760,22 +2206,15 @@
2760
2206
  if (!(parameters && Object.keys(parameters).length > 0)) {
2761
2207
  throw new RangeError(ERROR_TOKEN_EMPTY);
2762
2208
  }
2763
-
2764
2209
  if (!(parameters.username && parameters.password)) {
2765
2210
  throw new RangeError(ERROR_TOKEN_USERNAME_PASSWORD);
2766
2211
  }
2767
2212
  }
2768
2213
  }]);
2769
-
2770
- return PasswordGenerator;
2771
2214
  }(AbstractTokenGenerator);
2772
2215
 
2773
- var _token = new WeakMap();
2774
-
2775
- var _refreshTokenFunc = new WeakMap();
2776
-
2777
- /* eslint-disable camelcase */
2778
-
2216
+ var _token = /*#__PURE__*/new WeakMap();
2217
+ var _refreshTokenFunc = /*#__PURE__*/new WeakMap();
2779
2218
  /**
2780
2219
  * @deprecated ProvidedTokenGenerator is not an Oauth valid generator.
2781
2220
  * You should use one of the official generator or implement your own custom generator.
@@ -2783,38 +2222,28 @@
2783
2222
  var ProvidedTokenGenerator = /*#__PURE__*/function () {
2784
2223
  function ProvidedTokenGenerator(token) {
2785
2224
  var refreshTokenFunc = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
2786
-
2787
2225
  _classCallCheck(this, ProvidedTokenGenerator);
2788
-
2789
- _token.set(this, {
2790
- writable: true,
2791
- value: void 0
2792
- });
2793
-
2794
- _refreshTokenFunc.set(this, {
2795
- writable: true,
2796
- value: void 0
2797
- });
2798
-
2799
- _classPrivateFieldSet(this, _token, token);
2800
-
2801
- _classPrivateFieldSet(this, _refreshTokenFunc, refreshTokenFunc);
2226
+ _classPrivateFieldInitSpec(this, _token, void 0);
2227
+ _classPrivateFieldInitSpec(this, _refreshTokenFunc, void 0);
2228
+ _classPrivateFieldSet2(_token, this, token);
2229
+ _classPrivateFieldSet2(_refreshTokenFunc, this, refreshTokenFunc);
2802
2230
  }
2803
-
2804
- _createClass(ProvidedTokenGenerator, [{
2231
+ return _createClass(ProvidedTokenGenerator, [{
2232
+ key: "token",
2233
+ set: function set(token) {
2234
+ _classPrivateFieldSet2(_token, this, token);
2235
+ }
2236
+ }, {
2805
2237
  key: "generateToken",
2806
- // eslint-disable-next-line @typescript-eslint/no-unused-vars
2807
2238
  value: function generateToken() {
2808
- return Promise.resolve(_classPrivateFieldGet(this, _token));
2809
- } // eslint-disable-next-line @typescript-eslint/no-unused-vars
2810
-
2239
+ return Promise.resolve(_classPrivateFieldGet2(_token, this));
2240
+ }
2811
2241
  }, {
2812
2242
  key: "refreshToken",
2813
2243
  value: function refreshToken(accessToken) {
2814
- if (typeof _classPrivateFieldGet(this, _refreshTokenFunc) === 'function') {
2815
- return _classPrivateFieldGet(this, _refreshTokenFunc).call(this, accessToken);
2244
+ if (typeof _classPrivateFieldGet2(_refreshTokenFunc, this) === 'function') {
2245
+ return _classPrivateFieldGet2(_refreshTokenFunc, this).call(this, accessToken);
2816
2246
  }
2817
-
2818
2247
  return this.generateToken();
2819
2248
  }
2820
2249
  }, {
@@ -2822,100 +2251,60 @@
2822
2251
  value: function autoGenerateToken() {
2823
2252
  return this.generateToken();
2824
2253
  }
2825
- }, {
2826
- key: "token",
2827
- set: function set(token) {
2828
- _classPrivateFieldSet(this, _token, token);
2829
- }
2830
2254
  }]);
2831
-
2832
- return ProvidedTokenGenerator;
2833
2255
  }();
2834
2256
 
2835
2257
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
2836
2258
  function isResponse(response) {
2837
2259
  return typeof (response === null || response === void 0 ? void 0 : response.json) === 'function';
2838
2260
  }
2839
-
2840
2261
  function manageOauthError(body, response) {
2841
2262
  var error;
2842
-
2843
2263
  if (response) {
2844
2264
  error = getHttpErrorFromResponse(response);
2845
2265
  }
2846
-
2847
2266
  if (body.error === 'invalid_grant') {
2848
2267
  throw new InvalidGrantError(body.error, error);
2849
2268
  }
2850
-
2851
2269
  if (body.error === 'invalid_scope') {
2852
2270
  throw new InvalidScopeError(body.error, error);
2853
2271
  }
2854
-
2855
2272
  throw new OauthError(body.error, error);
2856
2273
  }
2857
-
2858
- var _tokenGenerator = new WeakMap();
2859
-
2860
- var _hasATokenBeenGenerated = new WeakMap();
2861
-
2862
- var _asyncStorage = new WeakMap();
2863
-
2864
- var _logger = new WeakMap();
2865
-
2274
+ var _tokenGenerator = /*#__PURE__*/new WeakMap();
2275
+ var _hasATokenBeenGenerated = /*#__PURE__*/new WeakMap();
2276
+ var _asyncStorage = /*#__PURE__*/new WeakMap();
2277
+ var _logger = /*#__PURE__*/new WeakMap();
2866
2278
  var TokenStorage = /*#__PURE__*/function () {
2867
2279
  function TokenStorage(tokenGenerator, asyncStorage) {
2868
2280
  var accessTokenKey = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'rest_client_sdk.api.access_token';
2869
2281
  var logger = arguments.length > 3 ? arguments[3] : undefined;
2870
-
2871
2282
  _classCallCheck(this, TokenStorage);
2872
-
2873
- _tokenGenerator.set(this, {
2874
- writable: true,
2875
- value: void 0
2876
- });
2877
-
2878
- _hasATokenBeenGenerated.set(this, {
2879
- writable: true,
2880
- value: void 0
2881
- });
2882
-
2283
+ _classPrivateFieldInitSpec(this, _tokenGenerator, void 0);
2284
+ _classPrivateFieldInitSpec(this, _hasATokenBeenGenerated, void 0);
2883
2285
  _defineProperty(this, "accessTokenKey", void 0);
2884
-
2885
- _asyncStorage.set(this, {
2886
- writable: true,
2887
- value: void 0
2888
- });
2889
-
2890
- _logger.set(this, {
2891
- writable: true,
2892
- value: void 0
2893
- });
2894
-
2286
+ _classPrivateFieldInitSpec(this, _asyncStorage, void 0);
2287
+ _classPrivateFieldInitSpec(this, _logger, void 0);
2895
2288
  if (logger) {
2896
- _classPrivateFieldSet(this, _logger, logger);
2289
+ _classPrivateFieldSet2(_logger, this, logger);
2897
2290
  }
2898
-
2899
- _classPrivateFieldSet(this, _tokenGenerator, tokenGenerator);
2900
-
2901
- _classPrivateFieldSet(this, _hasATokenBeenGenerated, false);
2902
-
2291
+ _classPrivateFieldSet2(_tokenGenerator, this, tokenGenerator);
2292
+ _classPrivateFieldSet2(_hasATokenBeenGenerated, this, false);
2903
2293
  this.setAsyncStorage(asyncStorage);
2904
2294
  this.accessTokenKey = accessTokenKey;
2905
2295
  this.handleTokenResponse = this.handleTokenResponse.bind(this);
2906
2296
  this.generateToken = memoizePromise(this.generateToken);
2907
2297
  this.refreshToken = memoizePromise(this.refreshToken);
2908
2298
  }
2909
-
2910
- _createClass(TokenStorage, [{
2299
+ return _createClass(TokenStorage, [{
2911
2300
  key: "setAsyncStorage",
2912
2301
  value: function setAsyncStorage(asyncStorage) {
2913
- _classPrivateFieldSet(this, _asyncStorage, asyncStorage);
2302
+ _classPrivateFieldSet2(_asyncStorage, this, asyncStorage);
2914
2303
  }
2915
2304
  }, {
2916
2305
  key: "hasAccessToken",
2917
2306
  value: function hasAccessToken() {
2918
- return _classPrivateFieldGet(this, _asyncStorage).getItem(this.accessTokenKey).then(function (accessToken) {
2307
+ return _classPrivateFieldGet2(_asyncStorage, this).getItem(this.accessTokenKey).then(function (accessToken) {
2919
2308
  return !!accessToken;
2920
2309
  });
2921
2310
  }
@@ -2930,33 +2319,27 @@
2930
2319
  key: "getAccessTokenObject",
2931
2320
  value: function getAccessTokenObject() {
2932
2321
  var _this = this;
2933
-
2934
- return _classPrivateFieldGet(this, _asyncStorage).getItem(this.accessTokenKey).then(function (token) {
2322
+ return _classPrivateFieldGet2(_asyncStorage, this).getItem(this.accessTokenKey).then(function (token) {
2935
2323
  if (token) {
2936
2324
  var tokenObject = JSON.parse(token);
2937
-
2938
2325
  if (_typeof(tokenObject) !== 'object') {
2939
2326
  return null;
2940
2327
  }
2941
-
2942
2328
  return tokenObject;
2943
2329
  }
2944
-
2945
- if (_classPrivateFieldGet(_this, _hasATokenBeenGenerated)) {
2330
+ if (_classPrivateFieldGet2(_hasATokenBeenGenerated, _this)) {
2946
2331
  return null;
2947
2332
  }
2948
-
2949
- if (typeof _classPrivateFieldGet(_this, _tokenGenerator).autoGenerateToken === 'function') {
2950
- return _classPrivateFieldGet(_this, _tokenGenerator).autoGenerateToken();
2333
+ if (typeof _classPrivateFieldGet2(_tokenGenerator, _this).autoGenerateToken === 'function') {
2334
+ return _classPrivateFieldGet2(_tokenGenerator, _this).autoGenerateToken();
2951
2335
  }
2952
-
2953
2336
  throw new Error('No token has been generated yet.');
2954
2337
  });
2955
2338
  }
2956
2339
  }, {
2957
2340
  key: "logout",
2958
2341
  value: function logout() {
2959
- return _classPrivateFieldGet(this, _asyncStorage).removeItem(this.accessTokenKey);
2342
+ return _classPrivateFieldGet2(_asyncStorage, this).removeItem(this.accessTokenKey);
2960
2343
  }
2961
2344
  }, {
2962
2345
  key: "_addExpiresAtToResponseData",
@@ -2964,30 +2347,25 @@
2964
2347
  if (!responseData) {
2965
2348
  return responseData;
2966
2349
  }
2967
-
2968
2350
  var updatedResponseData = _objectSpread2(_objectSpread2({}, responseData), {}, {
2969
2351
  expires_at: null
2970
2352
  });
2971
-
2972
- if (typeof updatedResponseData.expires_in !== 'undefined' && updatedResponseData.expires_in !== null // && updatedResponseData.expires_in >= 0
2353
+ if (typeof updatedResponseData.expires_in !== 'undefined' && updatedResponseData.expires_in !== null
2354
+ // && updatedResponseData.expires_in >= 0
2973
2355
  ) {
2974
- updatedResponseData.expires_at = Math.round(callTimestamp / 1000) + updatedResponseData.expires_in;
2975
- }
2976
-
2356
+ updatedResponseData.expires_at = Math.round(callTimestamp / 1000) + updatedResponseData.expires_in;
2357
+ }
2977
2358
  return updatedResponseData;
2978
2359
  }
2979
2360
  }, {
2980
2361
  key: "generateToken",
2981
2362
  value: function generateToken(parameters) {
2982
2363
  var _this2 = this;
2983
-
2984
2364
  var callTimestamp = Date.now();
2985
- return _classPrivateFieldGet(this, _tokenGenerator).generateToken(parameters).then(this.handleTokenResponse).then(function (body) {
2365
+ return _classPrivateFieldGet2(_tokenGenerator, this).generateToken(parameters).then(this.handleTokenResponse).then(function (body) {
2986
2366
  var updatedResponseData = _this2._addExpiresAtToResponseData(body, callTimestamp);
2987
-
2988
2367
  return _this2._storeAccessToken(updatedResponseData).then(function () {
2989
- _classPrivateFieldSet(_this2, _hasATokenBeenGenerated, true);
2990
-
2368
+ _classPrivateFieldSet2(_hasATokenBeenGenerated, _this2, true);
2991
2369
  return updatedResponseData;
2992
2370
  });
2993
2371
  });
@@ -2996,12 +2374,10 @@
2996
2374
  key: "refreshToken",
2997
2375
  value: function refreshToken() {
2998
2376
  var _this3 = this;
2999
-
3000
- return _classPrivateFieldGet(this, _asyncStorage).getItem(this.accessTokenKey).then(function (token) {
2377
+ return _classPrivateFieldGet2(_asyncStorage, this).getItem(this.accessTokenKey).then(function (token) {
3001
2378
  var callTimestamp = Date.now();
3002
- return _classPrivateFieldGet(_this3, _tokenGenerator).refreshToken(token ? JSON.parse(token) : null).then(_this3.handleTokenResponse).then(function (body) {
2379
+ return _classPrivateFieldGet2(_tokenGenerator, _this3).refreshToken(token ? JSON.parse(token) : null).then(_this3.handleTokenResponse).then(function (body) {
3003
2380
  var updatedResponseData = _this3._addExpiresAtToResponseData(body, callTimestamp);
3004
-
3005
2381
  return _this3._storeAccessToken(updatedResponseData).then(function () {
3006
2382
  return updatedResponseData;
3007
2383
  });
@@ -3014,11 +2390,9 @@
3014
2390
  if (isResponse(responseOrBody)) {
3015
2391
  var response = responseOrBody;
3016
2392
  var originalResponse = response.clone();
3017
-
3018
- if (_classPrivateFieldGet(this, _logger)) {
3019
- _classPrivateFieldGet(this, _logger).logResponse(response);
2393
+ if (_classPrivateFieldGet2(_logger, this)) {
2394
+ _classPrivateFieldGet2(_logger, this).logResponse(response);
3020
2395
  }
3021
-
3022
2396
  return response.json().then(function (body) {
3023
2397
  if (isOauthError(body)) {
3024
2398
  // throw error if response body is an oauth error
@@ -3027,31 +2401,26 @@
3027
2401
  // throw an error if response status code is an "error" status code
3028
2402
  throw getHttpErrorFromResponse(originalResponse);
3029
2403
  }
3030
-
3031
2404
  return body;
3032
2405
  })["catch"](function (err) {
3033
2406
  if (!(err instanceof OauthError)) {
3034
2407
  throw new OauthError(err.type, getHttpErrorFromResponse(originalResponse));
3035
2408
  }
3036
-
3037
2409
  throw err;
3038
2410
  });
3039
2411
  }
3040
-
3041
2412
  var body = responseOrBody;
3042
-
3043
2413
  if (isOauthError(body)) {
3044
2414
  // throw error if response body is an oauth error
3045
2415
  manageOauthError(body);
3046
2416
  }
3047
-
3048
2417
  return Promise.resolve(body);
3049
2418
  }
2419
+
3050
2420
  /**
3051
2421
  * Return the number of second when the token will expire
3052
2422
  * return value can be negative if the token is already expired
3053
2423
  */
3054
-
3055
2424
  }, {
3056
2425
  key: "getCurrentTokenExpiresIn",
3057
2426
  value: function getCurrentTokenExpiresIn() {
@@ -3059,11 +2428,9 @@
3059
2428
  if (accessTokenObject === null) {
3060
2429
  throw new Error('No token has been stored.');
3061
2430
  }
3062
-
3063
2431
  if (typeof accessTokenObject.expires_at === 'undefined' || accessTokenObject.expires_at === null) {
3064
2432
  return null;
3065
2433
  }
3066
-
3067
2434
  var now = Math.round(Date.now() / 1000);
3068
2435
  return accessTokenObject.expires_at - now;
3069
2436
  });
@@ -3071,11 +2438,9 @@
3071
2438
  }, {
3072
2439
  key: "_storeAccessToken",
3073
2440
  value: function _storeAccessToken(responseData) {
3074
- return _classPrivateFieldGet(this, _asyncStorage).setItem(this.accessTokenKey, JSON.stringify(responseData));
2441
+ return _classPrivateFieldGet2(_asyncStorage, this).setItem(this.accessTokenKey, JSON.stringify(responseData));
3075
2442
  }
3076
2443
  }]);
3077
-
3078
- return TokenStorage;
3079
2444
  }();
3080
2445
 
3081
2446
  exports.AbstractClient = AbstractClient;
@@ -3105,5 +2470,5 @@
3105
2470
 
3106
2471
  Object.defineProperty(exports, '__esModule', { value: true });
3107
2472
 
3108
- })));
2473
+ }));
3109
2474
  //# sourceMappingURL=index.cjs.map