dataflux 1.10.3 → 1.10.5

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.
Files changed (15) hide show
  1. package/dist/BasicObj.js +0 -53
  2. package/dist/Model.js +24 -148
  3. package/dist/Obj.js +0 -47
  4. package/dist/ObserverStore.js +21 -131
  5. package/dist/PersistentStore.js +10 -61
  6. package/dist/PubSub.js +1 -17
  7. package/dist/ReactStore.js +1 -52
  8. package/dist/Store.js +16 -116
  9. package/dist/SubObj.js +0 -45
  10. package/dist/dataflux.min.js +1 -1
  11. package/dist/dataflux.min.js.map +1 -1
  12. package/dist/fingerprint.js +1 -19
  13. package/dist/index.js +0 -3
  14. package/dist/modelHooksUtils.js +0 -28
  15. package/package.json +10 -10
package/dist/ObserverStore.js CHANGED
@@ -1,144 +1,88 @@
1
1
  "use strict";
2
2
 
3
3
  function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
4
-
5
4
  Object.defineProperty(exports, "__esModule", {
6
5
  value: true
7
6
  });
8
7
  exports["default"] = void 0;
9
-
10
8
  var _uuid = require("uuid");
11
-
12
9
  var _batchPromises = _interopRequireDefault(require("batch-promises"));
13
-
14
10
  var _PersistentStore2 = _interopRequireDefault(require("./PersistentStore"));
15
-
16
11
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
17
-
18
12
  function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
19
-
20
13
  function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
21
-
22
14
  function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
23
-
24
15
  function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
25
-
26
16
  function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
27
-
28
17
  function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
29
-
30
18
  function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
31
-
32
19
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
33
-
34
20
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
35
-
36
21
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
37
-
38
22
  function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get.bind(); } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
39
-
40
23
  function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
41
-
42
24
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
43
-
44
25
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
45
-
46
26
  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
47
-
48
27
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
49
-
50
28
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
51
-
52
29
  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
53
-
54
30
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
55
-
56
31
  function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
57
-
58
32
  function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
59
-
60
33
  function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
61
-
62
34
  function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
63
-
64
35
  function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
65
-
66
36
  function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
67
-
68
37
  function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
69
-
70
38
  function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
71
-
72
39
  function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
73
-
74
40
  function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
75
-
76
41
  var _queryPromises = /*#__PURE__*/new WeakMap();
77
-
78
42
  var _unsubPromises = /*#__PURE__*/new WeakMap();
79
-
80
43
  var _getUniqueSubs = /*#__PURE__*/new WeakMap();
81
-
82
44
  var _propagateChange = /*#__PURE__*/new WeakMap();
83
-
84
45
  var _appendIfNotExistent = /*#__PURE__*/new WeakMap();
85
-
86
46
  var _subscribeToObjects = /*#__PURE__*/new WeakMap();
87
-
88
47
  var _merge = /*#__PURE__*/new WeakMap();
89
-
90
48
  var _propagateInsertChange = /*#__PURE__*/new WeakSet();
91
-
92
49
  var ObserverStore = /*#__PURE__*/function (_PersistentStore) {
93
50
  _inherits(ObserverStore, _PersistentStore);
94
-
95
51
  var _super = _createSuper(ObserverStore);
96
-
97
52
  function ObserverStore(options) {
98
53
  var _this;
99
-
100
54
  _classCallCheck(this, ObserverStore);
101
-
102
55
  _this = _super.call(this, options);
103
-
104
56
  _classPrivateMethodInitSpec(_assertThisInitialized(_this), _propagateInsertChange);
105
-
106
57
  _classPrivateFieldInitSpec(_assertThisInitialized(_this), _queryPromises, {
107
58
  writable: true,
108
59
  value: []
109
60
  });
110
-
111
61
  _classPrivateFieldInitSpec(_assertThisInitialized(_this), _unsubPromises, {
112
62
  writable: true,
113
63
  value: []
114
64
  });
115
-
116
65
  _defineProperty(_assertThisInitialized(_this), "multipleSubscribe", function (subscriptions, callback) {
117
66
  var dataPayload = {};
118
67
  var subKey = (0, _uuid.v4)();
119
-
120
68
  var areAllDone = function areAllDone() {
121
69
  return subscriptions.map(function (_ref) {
122
70
  var _ref2 = _slicedToArray(_ref, 1),
123
- name = _ref2[0];
124
-
71
+ name = _ref2[0];
125
72
  return name;
126
73
  }).every(function (name) {
127
74
  return dataPayload[name] !== undefined;
128
75
  });
129
76
  };
130
-
131
77
  Promise.all(subscriptions.map(function (sub) {
132
78
  var _sub = _slicedToArray(sub, 2),
133
- name = _sub[0],
134
- _sub$ = _sub[1],
135
- filterFunction = _sub$ === void 0 ? null : _sub$;
136
-
79
+ name = _sub[0],
80
+ _sub$ = _sub[1],
81
+ filterFunction = _sub$ === void 0 ? null : _sub$;
137
82
  var wrappedCallback = function wrappedCallback(data) {
138
83
  dataPayload[name] = data;
139
84
  return areAllDone() && callback(dataPayload);
140
85
  };
141
-
142
86
  return _this.subscribe(name, wrappedCallback, filterFunction);
143
87
  })).then(function (subKeys) {
144
88
  _this._multipleSubscribed[subKey] = subKeys;
@@ -146,38 +90,29 @@ var ObserverStore = /*#__PURE__*/function (_PersistentStore) {
146
90
  });
147
91
  return subKey;
148
92
  });
149
-
150
93
  _defineProperty(_assertThisInitialized(_this), "subscribe", function (type, callback, filterFunction) {
151
94
  var _this$_subscribed, _this$_subscribed$typ;
152
-
153
95
  var subKey = (0, _uuid.v4)();
154
96
  (_this$_subscribed$typ = (_this$_subscribed = _this._subscribed)[type]) !== null && _this$_subscribed$typ !== void 0 ? _this$_subscribed$typ : _this$_subscribed[type] = {};
155
-
156
97
  var prom = _this.find(type, filterFunction).then(function (data) {
157
98
  _classPrivateFieldGet(_assertThisInitialized(_this), _subscribeToObjects).call(_assertThisInitialized(_this), type, data, {
158
99
  callback: callback,
159
100
  filterFunction: filterFunction,
160
101
  subKey: subKey
161
102
  });
162
-
163
103
  callback(data);
164
104
  });
165
-
166
105
  _classPrivateFieldGet(_assertThisInitialized(_this), _queryPromises).push(prom);
167
-
168
106
  return subKey;
169
107
  });
170
-
171
108
  _defineProperty(_assertThisInitialized(_this), "unsubscribe", function (key) {
172
109
  _classPrivateFieldSet(_assertThisInitialized(_this), _unsubPromises, (_classPrivateFieldGet(_assertThisInitialized(_this), _queryPromises).length ? Promise.all(_classPrivateFieldGet(_assertThisInitialized(_this), _queryPromises)) : Promise.resolve()).then(function () {
173
110
  if (_this._multipleSubscribed[key]) {
174
111
  var _iterator = _createForOfIteratorHelper(_this._multipleSubscribed[key]),
175
- _step;
176
-
112
+ _step;
177
113
  try {
178
114
  for (_iterator.s(); !(_step = _iterator.n()).done;) {
179
115
  var sub = _step.value;
180
-
181
116
  _this.unsubscribe(sub);
182
117
  }
183
118
  } catch (err) {
@@ -185,7 +120,6 @@ var ObserverStore = /*#__PURE__*/function (_PersistentStore) {
185
120
  } finally {
186
121
  _iterator.f();
187
122
  }
188
-
189
123
  delete _this._multipleSubscribed[key];
190
124
  } else {
191
125
  for (var type in _this._subscribed) {
@@ -193,10 +127,11 @@ var ObserverStore = /*#__PURE__*/function (_PersistentStore) {
193
127
  _this._subscribed[type][id] = _this._subscribed[type][id].filter(function (i) {
194
128
  return i.subKey !== key;
195
129
  });
196
- _this._subscribed[type]["*"] = _this._subscribed[type]["*"].filter(function (i) {
197
- return i.subKey !== key;
198
- });
199
-
130
+ if (_this._subscribed[type]["*"]) {
131
+ _this._subscribed[type]["*"] = _this._subscribed[type]["*"].filter(function (i) {
132
+ return i.subKey !== key;
133
+ });
134
+ }
200
135
  if (_this._subscribed[type][id].length === 0) {
201
136
  delete _this._subscribed[type][id];
202
137
  }
@@ -205,29 +140,23 @@ var ObserverStore = /*#__PURE__*/function (_PersistentStore) {
205
140
  }
206
141
  }));
207
142
  });
208
-
209
143
  _classPrivateFieldInitSpec(_assertThisInitialized(_this), _getUniqueSubs, {
210
144
  writable: true,
211
145
  value: function value(objects, type) {
212
146
  var out = {};
213
-
214
147
  var _iterator2 = _createForOfIteratorHelper(objects),
215
- _step2;
216
-
148
+ _step2;
217
149
  try {
218
150
  for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
219
151
  var object = _step2.value;
220
152
  var objectId = object.getId();
221
153
  var typeChannel = _this._subscribed[type] || {};
222
154
  var subscribedToObject = typeChannel[objectId] || [];
223
-
224
155
  var _iterator3 = _createForOfIteratorHelper(subscribedToObject),
225
- _step3;
226
-
156
+ _step3;
227
157
  try {
228
158
  for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
229
159
  var _sub$subKey, _out$_sub$subKey;
230
-
231
160
  var sub = _step3.value;
232
161
  (_out$_sub$subKey = out[_sub$subKey = sub.subKey]) !== null && _out$_sub$subKey !== void 0 ? _out$_sub$subKey : out[_sub$subKey] = sub;
233
162
  }
@@ -242,11 +171,9 @@ var ObserverStore = /*#__PURE__*/function (_PersistentStore) {
242
171
  } finally {
243
172
  _iterator2.f();
244
173
  }
245
-
246
174
  return Object.values(out);
247
175
  }
248
176
  });
249
-
250
177
  _classPrivateFieldInitSpec(_assertThisInitialized(_this), _propagateChange, {
251
178
  writable: true,
252
179
  value: function value() {
@@ -254,21 +181,17 @@ var ObserverStore = /*#__PURE__*/function (_PersistentStore) {
254
181
  return (_classPrivateFieldGet(_assertThisInitialized(_this), _unsubPromises).length ? Promise.all(_classPrivateFieldGet(_assertThisInitialized(_this), _unsubPromises)) : Promise.resolve()).then(function () {
255
182
  if (objects.length) {
256
183
  var type = objects[0].getModel().getType();
257
-
258
184
  var uniqueSubs = _classPrivateFieldGet(_assertThisInitialized(_this), _getUniqueSubs).call(_assertThisInitialized(_this), objects, type);
259
-
260
185
  (0, _batchPromises["default"])(10, uniqueSubs, function (_ref3) {
261
186
  var callback = _ref3.callback,
262
- filterFunction = _ref3.filterFunction;
187
+ filterFunction = _ref3.filterFunction;
263
188
  return _this.find(type, filterFunction).then(callback);
264
189
  });
265
190
  }
266
-
267
191
  return objects;
268
192
  });
269
193
  }
270
194
  });
271
-
272
195
  _classPrivateFieldInitSpec(_assertThisInitialized(_this), _appendIfNotExistent, {
273
196
  writable: true,
274
197
  value: function value(arr, item) {
@@ -280,23 +203,18 @@ var ObserverStore = /*#__PURE__*/function (_PersistentStore) {
280
203
  }
281
204
  }
282
205
  });
283
-
284
206
  _classPrivateFieldInitSpec(_assertThisInitialized(_this), _subscribeToObjects, {
285
207
  writable: true,
286
208
  value: function value(type, objectsToSubscribe, item) {
287
209
  var _this$_subscribed$typ2, _, _this$_subscribed$typ3;
288
-
289
210
  var _iterator4 = _createForOfIteratorHelper(objectsToSubscribe),
290
- _step4;
291
-
211
+ _step4;
292
212
  try {
293
213
  for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
294
214
  var _this$_subscribed$typ4, _this$_subscribed$typ5;
295
-
296
215
  var object = _step4.value;
297
216
  var id = object.getId();
298
217
  (_this$_subscribed$typ5 = (_this$_subscribed$typ4 = _this._subscribed[type])[id]) !== null && _this$_subscribed$typ5 !== void 0 ? _this$_subscribed$typ5 : _this$_subscribed$typ4[id] = [];
299
-
300
218
  _classPrivateFieldGet(_assertThisInitialized(_this), _appendIfNotExistent).call(_assertThisInitialized(_this), _this._subscribed[type][id], item);
301
219
  }
302
220
  } catch (err) {
@@ -304,84 +222,68 @@ var ObserverStore = /*#__PURE__*/function (_PersistentStore) {
304
222
  } finally {
305
223
  _iterator4.f();
306
224
  }
307
-
308
225
  (_this$_subscribed$typ3 = (_this$_subscribed$typ2 = _this._subscribed[type])[_ = "*"]) !== null && _this$_subscribed$typ3 !== void 0 ? _this$_subscribed$typ3 : _this$_subscribed$typ2[_] = [];
309
-
310
226
  _classPrivateFieldGet(_assertThisInitialized(_this), _appendIfNotExistent).call(_assertThisInitialized(_this), _this._subscribed[type]["*"], item);
311
227
  }
312
228
  });
313
-
314
229
  _defineProperty(_assertThisInitialized(_this), "refresh", function (type) {
315
230
  var refreshByType = function refreshByType(type) {
316
231
  _this.pubSub.publish("refresh", {
317
232
  status: "start",
318
233
  model: type
319
234
  });
320
-
321
235
  return _this.refreshObjectByType(type).then(function (_ref5) {
322
236
  var _ref6 = _slicedToArray(_ref5, 3),
323
- inserted = _ref6[0],
324
- updated = _ref6[1],
325
- deleted = _ref6[2];
326
-
237
+ inserted = _ref6[0],
238
+ updated = _ref6[1],
239
+ deleted = _ref6[2];
327
240
  var item = _this.models[type];
328
241
  return Promise.all([_classPrivateMethodGet(_assertThisInitialized(_this), _propagateInsertChange, _propagateInsertChange2).call(_assertThisInitialized(_this), type, inserted), _classPrivateFieldGet(_assertThisInitialized(_this), _propagateChange).call(_assertThisInitialized(_this), updated), _classPrivateFieldGet(_assertThisInitialized(_this), _propagateChange).call(_assertThisInitialized(_this), deleted)]).then(function () {
329
242
  _this.pubSub.publish("refresh", {
330
243
  status: "end",
331
244
  model: type
332
245
  });
333
-
334
246
  return item.promise;
335
247
  });
336
248
  });
337
249
  };
338
-
339
250
  if (type) {
340
251
  return refreshByType(type);
341
252
  } else {
342
253
  return Promise.all(Object.keys(_this.models).map(refreshByType));
343
254
  }
344
255
  });
345
-
346
256
  _classPrivateFieldInitSpec(_assertThisInitialized(_this), _merge, {
347
257
  writable: true,
348
258
  value: function value(originalObject, newObject) {
349
259
  for (var key in newObject) {
350
260
  originalObject[key] = newObject[key];
351
261
  }
352
-
353
262
  originalObject.update();
354
263
  }
355
264
  });
356
-
357
265
  _this._subscribed = {};
358
266
  _this._multipleSubscribed = {};
359
-
360
267
  if (options.autoRefresh && typeof options.autoRefresh === "number") {
361
268
  setInterval(_this.refresh, options.autoRefresh);
362
269
  }
363
-
364
270
  return _this;
365
271
  }
366
-
367
272
  _createClass(ObserverStore, [{
368
273
  key: "update",
369
274
  value: function update(objects, skipSave) {
370
275
  if (!skipSave) {
371
276
  _classPrivateFieldGet(this, _propagateChange).call(this, objects);
372
277
  }
373
-
374
278
  return _get(_getPrototypeOf(ObserverStore.prototype), "update", this).call(this, objects, skipSave).then(_classPrivateFieldGet(this, _propagateChange));
375
279
  }
376
280
  }, {
377
281
  key: "insert",
378
282
  value: function insert(type, objects) {
379
283
  var _this2 = this;
380
-
381
284
  objects = Array.isArray(objects) ? objects : [objects];
382
285
  return _get(_getPrototypeOf(ObserverStore.prototype), "insert", this).call(this, type, objects).then(function (objects) {
383
286
  _classPrivateMethodGet(_this2, _propagateInsertChange, _propagateInsertChange2).call(_this2, type, objects);
384
-
385
287
  return objects;
386
288
  });
387
289
  }
@@ -389,11 +291,9 @@ var ObserverStore = /*#__PURE__*/function (_PersistentStore) {
389
291
  key: "mock",
390
292
  value: function mock(type, objects) {
391
293
  var _this3 = this;
392
-
393
294
  objects = Array.isArray(objects) ? objects : [objects];
394
295
  return _get(_getPrototypeOf(ObserverStore.prototype), "mock", this).call(this, type, objects).then(function (objects) {
395
296
  _classPrivateMethodGet(_this3, _propagateInsertChange, _propagateInsertChange2).call(_this3, type, objects);
396
-
397
297
  return objects;
398
298
  });
399
299
  }
@@ -403,28 +303,21 @@ var ObserverStore = /*#__PURE__*/function (_PersistentStore) {
403
303
  return _get(_getPrototypeOf(ObserverStore.prototype), "delete", this).call(this, typeOrObjects, filterFunction).then(_classPrivateFieldGet(this, _propagateChange));
404
304
  }
405
305
  }]);
406
-
407
306
  return ObserverStore;
408
307
  }(_PersistentStore2["default"]);
409
-
410
308
  function _propagateInsertChange2(type, newObjects) {
411
309
  var _this4 = this;
412
-
413
310
  return (_classPrivateFieldGet(this, _unsubPromises).length ? Promise.all(_classPrivateFieldGet(this, _unsubPromises)) : Promise.resolve()).then(function () {
414
311
  if (_this4._subscribed[type]) {
415
312
  var uniqueSubs = {};
416
313
  var objects = Object.values(_this4._subscribed[type]);
417
-
418
314
  for (var _i2 = 0, _objects = objects; _i2 < _objects.length; _i2++) {
419
315
  var object = _objects[_i2];
420
-
421
316
  var _iterator5 = _createForOfIteratorHelper(object),
422
- _step5;
423
-
317
+ _step5;
424
318
  try {
425
319
  for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
426
320
  var sub = _step5.value;
427
-
428
321
  if (!uniqueSubs[sub.subKey]) {
429
322
  uniqueSubs[sub.subKey] = sub;
430
323
  }
@@ -435,23 +328,21 @@ function _propagateInsertChange2(type, newObjects) {
435
328
  _iterator5.f();
436
329
  }
437
330
  }
438
-
439
331
  var possibleSubs = Object.values(uniqueSubs);
440
332
  (0, _batchPromises["default"])(10, possibleSubs, function (_ref7) {
441
333
  var callback = _ref7.callback,
442
- filterFunction = _ref7.filterFunction,
443
- subKey = _ref7.subKey;
334
+ filterFunction = _ref7.filterFunction,
335
+ subKey = _ref7.subKey;
444
336
  var objectsToSubscribe = filterFunction ? newObjects.filter(filterFunction) : newObjects;
445
-
446
337
  if (objectsToSubscribe.length) {
447
338
  // Check if the new objects matter
339
+
448
340
  return _this4.find(type, filterFunction).then(function (data) {
449
341
  _classPrivateFieldGet(_this4, _subscribeToObjects).call(_this4, type, objectsToSubscribe, {
450
342
  callback: callback,
451
343
  filterFunction: filterFunction,
452
344
  subKey: subKey
453
345
  });
454
-
455
346
  return data;
456
347
  }).then(callback);
457
348
  }
@@ -459,6 +350,5 @@ function _propagateInsertChange2(type, newObjects) {
459
350
  }
460
351
  });
461
352
  }
462
-
463
353
  var _default = ObserverStore;
464
354
  exports["default"] = _default;