dataflux 1.10.4 → 1.11.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.
Files changed (16) hide show
  1. package/README.md +2 -0
  2. package/dist/BasicObj.js +0 -53
  3. package/dist/Model.js +24 -148
  4. package/dist/Obj.js +0 -47
  5. package/dist/ObserverStore.js +16 -129
  6. package/dist/PersistentStore.js +10 -61
  7. package/dist/PubSub.js +1 -17
  8. package/dist/ReactStore.js +1 -52
  9. package/dist/Store.js +51 -148
  10. package/dist/SubObj.js +0 -45
  11. package/dist/dataflux.min.js +1 -1
  12. package/dist/dataflux.min.js.map +1 -1
  13. package/dist/fingerprint.js +1 -19
  14. package/dist/index.js +0 -3
  15. package/dist/modelHooksUtils.js +0 -28
  16. package/package.json +9 -9
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,13 +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
-
197
130
  if (_this._subscribed[type]["*"]) {
198
131
  _this._subscribed[type]["*"] = _this._subscribed[type]["*"].filter(function (i) {
199
132
  return i.subKey !== key;
200
133
  });
201
134
  }
202
-
203
135
  if (_this._subscribed[type][id].length === 0) {
204
136
  delete _this._subscribed[type][id];
205
137
  }
@@ -208,29 +140,23 @@ var ObserverStore = /*#__PURE__*/function (_PersistentStore) {
208
140
  }
209
141
  }));
210
142
  });
211
-
212
143
  _classPrivateFieldInitSpec(_assertThisInitialized(_this), _getUniqueSubs, {
213
144
  writable: true,
214
145
  value: function value(objects, type) {
215
146
  var out = {};
216
-
217
147
  var _iterator2 = _createForOfIteratorHelper(objects),
218
- _step2;
219
-
148
+ _step2;
220
149
  try {
221
150
  for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
222
151
  var object = _step2.value;
223
152
  var objectId = object.getId();
224
153
  var typeChannel = _this._subscribed[type] || {};
225
154
  var subscribedToObject = typeChannel[objectId] || [];
226
-
227
155
  var _iterator3 = _createForOfIteratorHelper(subscribedToObject),
228
- _step3;
229
-
156
+ _step3;
230
157
  try {
231
158
  for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
232
159
  var _sub$subKey, _out$_sub$subKey;
233
-
234
160
  var sub = _step3.value;
235
161
  (_out$_sub$subKey = out[_sub$subKey = sub.subKey]) !== null && _out$_sub$subKey !== void 0 ? _out$_sub$subKey : out[_sub$subKey] = sub;
236
162
  }
@@ -245,11 +171,9 @@ var ObserverStore = /*#__PURE__*/function (_PersistentStore) {
245
171
  } finally {
246
172
  _iterator2.f();
247
173
  }
248
-
249
174
  return Object.values(out);
250
175
  }
251
176
  });
252
-
253
177
  _classPrivateFieldInitSpec(_assertThisInitialized(_this), _propagateChange, {
254
178
  writable: true,
255
179
  value: function value() {
@@ -257,21 +181,17 @@ var ObserverStore = /*#__PURE__*/function (_PersistentStore) {
257
181
  return (_classPrivateFieldGet(_assertThisInitialized(_this), _unsubPromises).length ? Promise.all(_classPrivateFieldGet(_assertThisInitialized(_this), _unsubPromises)) : Promise.resolve()).then(function () {
258
182
  if (objects.length) {
259
183
  var type = objects[0].getModel().getType();
260
-
261
184
  var uniqueSubs = _classPrivateFieldGet(_assertThisInitialized(_this), _getUniqueSubs).call(_assertThisInitialized(_this), objects, type);
262
-
263
185
  (0, _batchPromises["default"])(10, uniqueSubs, function (_ref3) {
264
186
  var callback = _ref3.callback,
265
- filterFunction = _ref3.filterFunction;
187
+ filterFunction = _ref3.filterFunction;
266
188
  return _this.find(type, filterFunction).then(callback);
267
189
  });
268
190
  }
269
-
270
191
  return objects;
271
192
  });
272
193
  }
273
194
  });
274
-
275
195
  _classPrivateFieldInitSpec(_assertThisInitialized(_this), _appendIfNotExistent, {
276
196
  writable: true,
277
197
  value: function value(arr, item) {
@@ -283,23 +203,18 @@ var ObserverStore = /*#__PURE__*/function (_PersistentStore) {
283
203
  }
284
204
  }
285
205
  });
286
-
287
206
  _classPrivateFieldInitSpec(_assertThisInitialized(_this), _subscribeToObjects, {
288
207
  writable: true,
289
208
  value: function value(type, objectsToSubscribe, item) {
290
209
  var _this$_subscribed$typ2, _, _this$_subscribed$typ3;
291
-
292
210
  var _iterator4 = _createForOfIteratorHelper(objectsToSubscribe),
293
- _step4;
294
-
211
+ _step4;
295
212
  try {
296
213
  for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
297
214
  var _this$_subscribed$typ4, _this$_subscribed$typ5;
298
-
299
215
  var object = _step4.value;
300
216
  var id = object.getId();
301
217
  (_this$_subscribed$typ5 = (_this$_subscribed$typ4 = _this._subscribed[type])[id]) !== null && _this$_subscribed$typ5 !== void 0 ? _this$_subscribed$typ5 : _this$_subscribed$typ4[id] = [];
302
-
303
218
  _classPrivateFieldGet(_assertThisInitialized(_this), _appendIfNotExistent).call(_assertThisInitialized(_this), _this._subscribed[type][id], item);
304
219
  }
305
220
  } catch (err) {
@@ -307,84 +222,68 @@ var ObserverStore = /*#__PURE__*/function (_PersistentStore) {
307
222
  } finally {
308
223
  _iterator4.f();
309
224
  }
310
-
311
225
  (_this$_subscribed$typ3 = (_this$_subscribed$typ2 = _this._subscribed[type])[_ = "*"]) !== null && _this$_subscribed$typ3 !== void 0 ? _this$_subscribed$typ3 : _this$_subscribed$typ2[_] = [];
312
-
313
226
  _classPrivateFieldGet(_assertThisInitialized(_this), _appendIfNotExistent).call(_assertThisInitialized(_this), _this._subscribed[type]["*"], item);
314
227
  }
315
228
  });
316
-
317
229
  _defineProperty(_assertThisInitialized(_this), "refresh", function (type) {
318
230
  var refreshByType = function refreshByType(type) {
319
231
  _this.pubSub.publish("refresh", {
320
232
  status: "start",
321
233
  model: type
322
234
  });
323
-
324
235
  return _this.refreshObjectByType(type).then(function (_ref5) {
325
236
  var _ref6 = _slicedToArray(_ref5, 3),
326
- inserted = _ref6[0],
327
- updated = _ref6[1],
328
- deleted = _ref6[2];
329
-
237
+ inserted = _ref6[0],
238
+ updated = _ref6[1],
239
+ deleted = _ref6[2];
330
240
  var item = _this.models[type];
331
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 () {
332
242
  _this.pubSub.publish("refresh", {
333
243
  status: "end",
334
244
  model: type
335
245
  });
336
-
337
246
  return item.promise;
338
247
  });
339
248
  });
340
249
  };
341
-
342
250
  if (type) {
343
251
  return refreshByType(type);
344
252
  } else {
345
253
  return Promise.all(Object.keys(_this.models).map(refreshByType));
346
254
  }
347
255
  });
348
-
349
256
  _classPrivateFieldInitSpec(_assertThisInitialized(_this), _merge, {
350
257
  writable: true,
351
258
  value: function value(originalObject, newObject) {
352
259
  for (var key in newObject) {
353
260
  originalObject[key] = newObject[key];
354
261
  }
355
-
356
262
  originalObject.update();
357
263
  }
358
264
  });
359
-
360
265
  _this._subscribed = {};
361
266
  _this._multipleSubscribed = {};
362
-
363
267
  if (options.autoRefresh && typeof options.autoRefresh === "number") {
364
268
  setInterval(_this.refresh, options.autoRefresh);
365
269
  }
366
-
367
270
  return _this;
368
271
  }
369
-
370
272
  _createClass(ObserverStore, [{
371
273
  key: "update",
372
274
  value: function update(objects, skipSave) {
373
275
  if (!skipSave) {
374
276
  _classPrivateFieldGet(this, _propagateChange).call(this, objects);
375
277
  }
376
-
377
278
  return _get(_getPrototypeOf(ObserverStore.prototype), "update", this).call(this, objects, skipSave).then(_classPrivateFieldGet(this, _propagateChange));
378
279
  }
379
280
  }, {
380
281
  key: "insert",
381
282
  value: function insert(type, objects) {
382
283
  var _this2 = this;
383
-
384
284
  objects = Array.isArray(objects) ? objects : [objects];
385
285
  return _get(_getPrototypeOf(ObserverStore.prototype), "insert", this).call(this, type, objects).then(function (objects) {
386
286
  _classPrivateMethodGet(_this2, _propagateInsertChange, _propagateInsertChange2).call(_this2, type, objects);
387
-
388
287
  return objects;
389
288
  });
390
289
  }
@@ -392,11 +291,9 @@ var ObserverStore = /*#__PURE__*/function (_PersistentStore) {
392
291
  key: "mock",
393
292
  value: function mock(type, objects) {
394
293
  var _this3 = this;
395
-
396
294
  objects = Array.isArray(objects) ? objects : [objects];
397
295
  return _get(_getPrototypeOf(ObserverStore.prototype), "mock", this).call(this, type, objects).then(function (objects) {
398
296
  _classPrivateMethodGet(_this3, _propagateInsertChange, _propagateInsertChange2).call(_this3, type, objects);
399
-
400
297
  return objects;
401
298
  });
402
299
  }
@@ -406,28 +303,21 @@ var ObserverStore = /*#__PURE__*/function (_PersistentStore) {
406
303
  return _get(_getPrototypeOf(ObserverStore.prototype), "delete", this).call(this, typeOrObjects, filterFunction).then(_classPrivateFieldGet(this, _propagateChange));
407
304
  }
408
305
  }]);
409
-
410
306
  return ObserverStore;
411
307
  }(_PersistentStore2["default"]);
412
-
413
308
  function _propagateInsertChange2(type, newObjects) {
414
309
  var _this4 = this;
415
-
416
310
  return (_classPrivateFieldGet(this, _unsubPromises).length ? Promise.all(_classPrivateFieldGet(this, _unsubPromises)) : Promise.resolve()).then(function () {
417
311
  if (_this4._subscribed[type]) {
418
312
  var uniqueSubs = {};
419
313
  var objects = Object.values(_this4._subscribed[type]);
420
-
421
314
  for (var _i2 = 0, _objects = objects; _i2 < _objects.length; _i2++) {
422
315
  var object = _objects[_i2];
423
-
424
316
  var _iterator5 = _createForOfIteratorHelper(object),
425
- _step5;
426
-
317
+ _step5;
427
318
  try {
428
319
  for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
429
320
  var sub = _step5.value;
430
-
431
321
  if (!uniqueSubs[sub.subKey]) {
432
322
  uniqueSubs[sub.subKey] = sub;
433
323
  }
@@ -438,23 +328,21 @@ function _propagateInsertChange2(type, newObjects) {
438
328
  _iterator5.f();
439
329
  }
440
330
  }
441
-
442
331
  var possibleSubs = Object.values(uniqueSubs);
443
332
  (0, _batchPromises["default"])(10, possibleSubs, function (_ref7) {
444
333
  var callback = _ref7.callback,
445
- filterFunction = _ref7.filterFunction,
446
- subKey = _ref7.subKey;
334
+ filterFunction = _ref7.filterFunction,
335
+ subKey = _ref7.subKey;
447
336
  var objectsToSubscribe = filterFunction ? newObjects.filter(filterFunction) : newObjects;
448
-
449
337
  if (objectsToSubscribe.length) {
450
338
  // Check if the new objects matter
339
+
451
340
  return _this4.find(type, filterFunction).then(function (data) {
452
341
  _classPrivateFieldGet(_this4, _subscribeToObjects).call(_this4, type, objectsToSubscribe, {
453
342
  callback: callback,
454
343
  filterFunction: filterFunction,
455
344
  subKey: subKey
456
345
  });
457
-
458
346
  return data;
459
347
  }).then(callback);
460
348
  }
@@ -462,6 +350,5 @@ function _propagateInsertChange2(type, newObjects) {
462
350
  }
463
351
  });
464
352
  }
465
-
466
353
  var _default = ObserverStore;
467
354
  exports["default"] = _default;