@ember-data/store 5.2.0-alpha.5 → 5.2.0

package/addon/-private.js

@@ -1062,205 +1062,11 @@ function detectMerge(typesCache, identifier, data, newId, lids) {
   }
   return false;
 }
-let tokenId = 0;
-const CacheOperations = new Set(['added', 'removed', 'state', 'updated']);
-function isCacheOperationValue(value) {
-  return CacheOperations.has(value);
-}
-function runLoopIsFlushing() {
-  //@ts-expect-error
-  return !!_backburner.currentInstance && _backburner._autorun !== true;
-}
-const Cache = new Map();
-const Tokens = new Map();
-// TODO this isn't importable anyway, remove and use a map on the manager?
-function unsubscribe(token) {
-  let identifier = Tokens.get(token);
-  if (macroCondition(getOwnConfig().debug.LOG_NOTIFICATIONS)) {
-    if (!identifier) {
-      // eslint-disable-next-line no-console
-      console.log('Passed unknown unsubscribe token to unsubscribe', identifier);
-    }
-  }
-  if (identifier) {
-    Tokens.delete(token);
-    const map = Cache.get(identifier);
-    map?.delete(token);
-  }
-}
+var _class$1, _descriptor$1;
 
 /**
- * The NotificationManager provides the ability to subscribe to
- * changes to Cache state.
- *
- * This Feature is what allows EmberData to create subscriptions that
- * work with any framework or change-notification system.
- *
- * @class NotificationManager
- * @public
- */
-class NotificationManager {
-  constructor(store) {
-    this.store = store;
-    this.isDestroyed = false;
-    this._buffered = new Map();
-    this._hasFlush = false;
-  }
-
-  /**
-   * Subscribe to changes for a given resource identifier, resource addition/removal, or document addition/removal.
-   *
-   * ```ts
-   * export type CacheOperation = 'added' | 'removed' | 'updated' | 'state';
-   *
-   * export interface NotificationCallback {
-   *   (identifier: StableRecordIdentifier, notificationType: 'attributes' | 'relationships', key?: string): void;
-   *   (identifier: StableRecordIdentifier, notificationType: 'errors' | 'meta' | 'identity' | 'state'): void;
-   *   (identifier: StableRecordIdentifier, notificationType: NotificationType, key?: string): void;
-   * }
-   * export interface ResourceOperationCallback {
-   *   // resource updates
-   *   (identifier: StableRecordIdentifier, notificationType: CacheOperation): void;
-   * }
-   * export interface DocumentOperationCallback {
-   *   // document updates
-   *   (identifier: StableDocumentIdentifier, notificationType: CacheOperation): void;
-   * }
-   * ```
-   *
-   * @method subscribe
-   * @public
-   * @param {StableDocumentIdentifier | StableRecordIdentifier | 'resource' | 'document'} identifier
-   * @param {NotificationCallback | ResourceOperationCallback | DocumentOperationCallback} callback
-   * @returns {UnsubscribeToken} an opaque token to be used with unsubscribe
-   */
-
-  subscribe(identifier, callback) {
-    assert(`Expected to receive a stable Identifier to subscribe to`, identifier === 'resource' || identifier === 'document' || isStableIdentifier(identifier) || isDocumentIdentifier(identifier));
-    let map = Cache.get(identifier);
-    if (!map) {
-      map = new Map();
-      Cache.set(identifier, map);
-    }
-    let unsubToken = macroCondition(getOwnConfig().env.DEBUG) ? {
-      _tokenRef: tokenId++
-    } : {};
-    map.set(unsubToken, callback);
-    Tokens.set(unsubToken, identifier);
-    return unsubToken;
-  }
-
-  /**
-   * remove a previous subscription
-   *
-   * @method unsubscribe
-   * @public
-   * @param {UnsubscribeToken} token
-   */
-  unsubscribe(token) {
-    if (!this.isDestroyed) {
-      unsubscribe(token);
-    }
-  }
-
-  /**
-   * Custom Caches and Application Code should not call this method directly.
-   *
-   * @method notify
-   * @param identifier
-   * @param value
-   * @param key
-   * @return {Boolean} whether a notification was delivered to any subscribers
-   * @private
-   */
-
-  notify(identifier, value, key) {
-    assert(`Notify does not accept a key argument for the namespace '${value}'. Received key '${key || ''}'.`, !key || value === 'attributes' || value === 'relationships');
-    if (!isStableIdentifier(identifier) && !isDocumentIdentifier(identifier)) {
-      if (macroCondition(getOwnConfig().debug.LOG_NOTIFICATIONS)) {
-        // eslint-disable-next-line no-console
-        console.log(`Notifying: Expected to receive a stable Identifier to notify '${value}' '${key || ''}' with, but ${String(identifier)} is not in the cache`, identifier);
-      }
-      return false;
-    }
-    if (macroCondition(getOwnConfig().debug.LOG_NOTIFICATIONS)) {
-      // eslint-disable-next-line no-console
-      console.log(`Buffering Notify: ${String(identifier.lid)}\t${value}\t${key || ''}`);
-    }
-    const hasSubscribers = Boolean(Cache.get(identifier)?.size);
-    if (isCacheOperationValue(value) || hasSubscribers) {
-      let buffer = this._buffered.get(identifier);
-      if (!buffer) {
-        buffer = [];
-        this._buffered.set(identifier, buffer);
-      }
-      buffer.push([value, key]);
-      void this._scheduleNotify();
-    }
-    return hasSubscribers;
-  }
-  _onNextFlush(cb) {
-    this._onFlushCB = cb;
-  }
-  _scheduleNotify() {
-    const asyncFlush = this.store._enableAsyncFlush;
-    if (this._hasFlush) {
-      if (asyncFlush !== false && !runLoopIsFlushing()) {
-        return;
-      }
-    }
-    if (asyncFlush && !runLoopIsFlushing()) {
-      this._hasFlush = true;
-      return;
-    }
-    this._flush();
-  }
-  _flush() {
-    if (this._buffered.size) {
-      this._buffered.forEach((states, identifier) => {
-        states.forEach(args => {
-          // @ts-expect-error
-          this._flushNotification(identifier, args[0], args[1]);
-        });
-      });
-      this._buffered = new Map();
-    }
-    this._hasFlush = false;
-    this._onFlushCB?.();
-    this._onFlushCB = undefined;
-  }
-  _flushNotification(identifier, value, key) {
-    if (macroCondition(getOwnConfig().debug.LOG_NOTIFICATIONS)) {
-      // eslint-disable-next-line no-console
-      console.log(`Notifying: ${String(identifier)}\t${value}\t${key || ''}`);
-    }
-
-    // TODO for documents this will need to switch based on Identifier kind
-    if (isCacheOperationValue(value)) {
-      let callbackMap = Cache.get(isDocumentIdentifier(identifier) ? 'document' : 'resource');
-      if (callbackMap) {
-        callbackMap.forEach(cb => {
-          cb(identifier, value);
-        });
-      }
-    }
-    let callbackMap = Cache.get(identifier);
-    if (!callbackMap || !callbackMap.size) {
-      return false;
-    }
-    callbackMap.forEach(cb => {
-      // @ts-expect-error overload doesn't narrow within body
-      cb(identifier, value, key);
-    });
-    return true;
-  }
-  destroy() {
-    this.isDestroyed = true;
-    Tokens.clear();
-    Cache.clear();
-  }
-}
-var _class$1, _descriptor$1;
+  @module @ember-data/store
+*/
 /**
   @module @ember-data/store
 */
@@ -1288,7 +1094,7 @@ let RecordReference = (_class$1 = class RecordReference {
     });
   }
   destroy() {
-    unsubscribe(this.___token);
+    this.store.notifications.unsubscribe(this.___token);
   }
   get type() {
     return this.identifier().type;
@@ -2555,6 +2361,203 @@ class CacheManager {
     return _classPrivateFieldBase(this, _cache)[_cache].isDeletionCommitted(identifier);
   }
 }
+let tokenId = 0;
+const CacheOperations = new Set(['added', 'removed', 'state', 'updated']);
+function isCacheOperationValue(value) {
+  return CacheOperations.has(value);
+}
+function runLoopIsFlushing() {
+  //@ts-expect-error
+  return !!_backburner.currentInstance && _backburner._autorun !== true;
+}
+function _unsubscribe(tokens, token, cache) {
+  let identifier = tokens.get(token);
+  if (macroCondition(getOwnConfig().debug.LOG_NOTIFICATIONS)) {
+    if (!identifier) {
+      // eslint-disable-next-line no-console
+      console.log('Passed unknown unsubscribe token to unsubscribe', identifier);
+    }
+  }
+  if (identifier) {
+    tokens.delete(token);
+    const map = cache.get(identifier);
+    map?.delete(token);
+  }
+}
+
+/**
+ * The NotificationManager provides the ability to subscribe to
+ * changes to Cache state.
+ *
+ * This Feature is what allows EmberData to create subscriptions that
+ * work with any framework or change-notification system.
+ *
+ * @class NotificationManager
+ * @public
+ */
+class NotificationManager {
+  constructor(store) {
+    this.store = store;
+    this.isDestroyed = false;
+    this._buffered = new Map();
+    this._hasFlush = false;
+    this._cache = new Map();
+    this._tokens = new Map();
+  }
+
+  /**
+   * Subscribe to changes for a given resource identifier, resource addition/removal, or document addition/removal.
+   *
+   * ```ts
+   * export type CacheOperation = 'added' | 'removed' | 'updated' | 'state';
+   *
+   * export interface NotificationCallback {
+   *   (identifier: StableRecordIdentifier, notificationType: 'attributes' | 'relationships', key?: string): void;
+   *   (identifier: StableRecordIdentifier, notificationType: 'errors' | 'meta' | 'identity' | 'state'): void;
+   *   (identifier: StableRecordIdentifier, notificationType: NotificationType, key?: string): void;
+   * }
+   * export interface ResourceOperationCallback {
+   *   // resource updates
+   *   (identifier: StableRecordIdentifier, notificationType: CacheOperation): void;
+   * }
+   * export interface DocumentOperationCallback {
+   *   // document updates
+   *   (identifier: StableDocumentIdentifier, notificationType: CacheOperation): void;
+   * }
+   * ```
+   *
+   * @method subscribe
+   * @public
+   * @param {StableDocumentIdentifier | StableRecordIdentifier | 'resource' | 'document'} identifier
+   * @param {NotificationCallback | ResourceOperationCallback | DocumentOperationCallback} callback
+   * @returns {UnsubscribeToken} an opaque token to be used with unsubscribe
+   */
+
+  subscribe(identifier, callback) {
+    assert(`Expected to receive a stable Identifier to subscribe to`, identifier === 'resource' || identifier === 'document' || isStableIdentifier(identifier) || isDocumentIdentifier(identifier));
+    let map = this._cache.get(identifier);
+    if (!map) {
+      map = new Map();
+      this._cache.set(identifier, map);
+    }
+    let unsubToken = macroCondition(getOwnConfig().env.DEBUG) ? {
+      _tokenRef: tokenId++
+    } : {};
+    map.set(unsubToken, callback);
+    this._tokens.set(unsubToken, identifier);
+    return unsubToken;
+  }
+
+  /**
+   * remove a previous subscription
+   *
+   * @method unsubscribe
+   * @public
+   * @param {UnsubscribeToken} token
+   */
+  unsubscribe(token) {
+    if (!this.isDestroyed) {
+      _unsubscribe(this._tokens, token, this._cache);
+    }
+  }
+
+  /**
+   * Custom Caches and Application Code should not call this method directly.
+   *
+   * @method notify
+   * @param identifier
+   * @param value
+   * @param key
+   * @return {Boolean} whether a notification was delivered to any subscribers
+   * @private
+   */
+
+  notify(identifier, value, key) {
+    assert(`Notify does not accept a key argument for the namespace '${value}'. Received key '${key || ''}'.`, !key || value === 'attributes' || value === 'relationships');
+    if (!isStableIdentifier(identifier) && !isDocumentIdentifier(identifier)) {
+      if (macroCondition(getOwnConfig().debug.LOG_NOTIFICATIONS)) {
+        // eslint-disable-next-line no-console
+        console.log(`Notifying: Expected to receive a stable Identifier to notify '${value}' '${key || ''}' with, but ${String(identifier)} is not in the cache`, identifier);
+      }
+      return false;
+    }
+    if (macroCondition(getOwnConfig().debug.LOG_NOTIFICATIONS)) {
+      // eslint-disable-next-line no-console
+      console.log(`Buffering Notify: ${String(identifier.lid)}\t${value}\t${key || ''}`);
+    }
+    const hasSubscribers = Boolean(this._cache.get(identifier)?.size);
+    if (isCacheOperationValue(value) || hasSubscribers) {
+      let buffer = this._buffered.get(identifier);
+      if (!buffer) {
+        buffer = [];
+        this._buffered.set(identifier, buffer);
+      }
+      buffer.push([value, key]);
+      void this._scheduleNotify();
+    }
+    return hasSubscribers;
+  }
+  _onNextFlush(cb) {
+    this._onFlushCB = cb;
+  }
+  _scheduleNotify() {
+    const asyncFlush = this.store._enableAsyncFlush;
+    if (this._hasFlush) {
+      if (asyncFlush !== false && !runLoopIsFlushing()) {
+        return;
+      }
+    }
+    if (asyncFlush && !runLoopIsFlushing()) {
+      this._hasFlush = true;
+      return;
+    }
+    this._flush();
+  }
+  _flush() {
+    if (this._buffered.size) {
+      this._buffered.forEach((states, identifier) => {
+        states.forEach(args => {
+          // @ts-expect-error
+          this._flushNotification(identifier, args[0], args[1]);
+        });
+      });
+      this._buffered = new Map();
+    }
+    this._hasFlush = false;
+    this._onFlushCB?.();
+    this._onFlushCB = undefined;
+  }
+  _flushNotification(identifier, value, key) {
+    if (macroCondition(getOwnConfig().debug.LOG_NOTIFICATIONS)) {
+      // eslint-disable-next-line no-console
+      console.log(`Notifying: ${String(identifier)}\t${value}\t${key || ''}`);
+    }
+
+    // TODO for documents this will need to switch based on Identifier kind
+    if (isCacheOperationValue(value)) {
+      let callbackMap = this._cache.get(isDocumentIdentifier(identifier) ? 'document' : 'resource');
+      if (callbackMap) {
+        callbackMap.forEach(cb => {
+          cb(identifier, value);
+        });
+      }
+    }
+    let callbackMap = this._cache.get(identifier);
+    if (!callbackMap || !callbackMap.size) {
+      return false;
+    }
+    callbackMap.forEach(cb => {
+      // @ts-expect-error overload doesn't narrow within body
+      cb(identifier, value, key);
+    });
+    return true;
+  }
+  destroy() {
+    this.isDestroyed = true;
+    this._tokens.clear();
+    this._cache.clear();
+  }
+}
 var _class, _descriptor, _class3, _descriptor2;
 const ARRAY_GETTER_METHODS = new Set([Symbol.iterator, 'concat', 'entries', 'every', 'fill', 'filter', 'find', 'findIndex', 'flat', 'flatMap', 'forEach', 'includes', 'indexOf', 'join', 'keys', 'lastIndexOf', 'map', 'reduce', 'reduceRight', 'slice', 'some', 'values']);
 const ARRAY_SETTER_METHODS = new Set(['push', 'pop', 'unshift', 'shift', 'splice', 'sort']);
@@ -2661,13 +2664,13 @@ let IdentifierArray = (_class3 = class IdentifierArray {
     @type Store
     */
 
-  destroy() {
-    this.isDestroying = true;
+  destroy(clear) {
+    this.isDestroying = !clear;
     // changing the reference breaks the Proxy
     // this[SOURCE] = [];
     this[SOURCE].length = 0;
     this[NOTIFY]();
-    this.isDestroyed = true;
+    this.isDestroyed = !clear;
   }
 
   // length must be on self for proxied methods to work properly
@@ -2958,8 +2961,8 @@ class Collection extends IdentifierArray {
     });
     return promise;
   }
-  destroy() {
-    super.destroy();
+  destroy(clear) {
+    super.destroy(clear);
     this._manager._managed.delete(this);
     this._manager._pending.delete(this);
   }
@@ -2991,7 +2994,6 @@ function extractIdentifierFromRecord$1(record) {
   @module @ember-data/store
 */
 
-const RecordArraysCache = new Map();
 const FAKE_ARR = {};
 const SLICE_BATCH_SIZE = 1200;
 /**
@@ -3057,11 +3059,15 @@ class RecordArrayManager {
     this._pending = new Map();
     this._staged = new Map();
     this._keyedArrays = new Map();
-    this._identifiers = RecordArraysCache;
+    this._identifiers = new Map();
+    this._set = new Map();
+    this._visibilitySet = new Map();
     this._subscription = this.store.notifications.subscribe('resource', (identifier, type) => {
       if (type === 'added') {
+        this._visibilitySet.set(identifier, true);
         this.identifierAdded(identifier);
       } else if (type === 'removed') {
+        this._visibilitySet.set(identifier, false);
         this.identifierRemoved(identifier);
       } else if (type === 'state') {
         this.identifierChanged(identifier);
@@ -3073,7 +3079,7 @@ class RecordArrayManager {
     if (!pending || this.isDestroying || this.isDestroyed) {
       return;
     }
-    sync(array, pending);
+    sync(array, pending, this._set.get(array));
     this._pending.delete(array);
   }
 
@@ -3106,6 +3112,7 @@ class RecordArrayManager {
         manager: this
       });
       this._live.set(type, array);
+      this._set.set(array, new Set(identifiers));
     }
     return array;
   }
@@ -3123,8 +3130,9 @@ class RecordArrayManager {
     };
     let array = new Collection(options);
     this._managed.add(array);
+    this._set.set(array, new Set(options.identifiers || []));
     if (config.identifiers) {
-      associate(array, config.identifiers);
+      associate(this._identifiers, array, config.identifiers);
     }
     return array;
   }
@@ -3148,7 +3156,7 @@ class RecordArrayManager {
     const allPending = this._pending;
     let pending = new Map();
     if (includeManaged) {
-      let managed = RecordArraysCache.get(identifier);
+      let managed = this._identifiers.get(identifier);
       if (managed) {
         managed.forEach(arr => {
           let changes = allPending.get(arr);
@@ -3194,12 +3202,13 @@ class RecordArrayManager {
     const old = source.slice();
     source.length = 0;
     fastPush(source, identifiers);
+    this._set.set(array, new Set(identifiers));
     notifyArray(array);
     array.meta = payload.meta || null;
     array.links = payload.links || null;
     array.isLoaded = true;
-    disassociate(array, old);
-    associate(array, identifiers);
+    disassociate(this._identifiers, array, old);
+    associate(this._identifiers, array, identifiers);
   }
   identifierAdded(identifier) {
     let changeSets = this._getPendingFor(identifier, false);
@@ -3231,62 +3240,72 @@ class RecordArrayManager {
   }
   identifierChanged(identifier) {
     let newState = this.store._instanceCache.recordIsLoaded(identifier, true);
+
+    // if the change matches the most recent direct added/removed
+    // state, then we can ignore it
+    if (this._visibilitySet.get(identifier) === newState) {
+      return;
+    }
     if (newState) {
       this.identifierAdded(identifier);
     } else {
       this.identifierRemoved(identifier);
     }
   }
-  clear() {
-    this._live.forEach(array => array.destroy());
-    this._managed.forEach(array => array.destroy());
+  clear(isClear = true) {
+    this._live.forEach(array => array.destroy(isClear));
+    this._managed.forEach(array => array.destroy(isClear));
     this._managed.clear();
-    RecordArraysCache.clear();
+    this._identifiers.clear();
+    this._pending.clear();
+    this._set.forEach(set => set.clear());
+    this._visibilitySet.clear();
   }
   destroy() {
     this.isDestroying = true;
-    this.clear();
+    this.clear(false);
     this._live.clear();
     this.isDestroyed = true;
     // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
     this.store.notifications.unsubscribe(this._subscription);
   }
 }
-function associate(array, identifiers) {
+function associate(ArraysCache, array, identifiers) {
   for (let i = 0; i < identifiers.length; i++) {
     let identifier = identifiers[i];
-    let cache = RecordArraysCache.get(identifier);
+    let cache = ArraysCache.get(identifier);
     if (!cache) {
       cache = new Set();
-      RecordArraysCache.set(identifier, cache);
+      ArraysCache.set(identifier, cache);
     }
     cache.add(array);
   }
 }
-function disassociate(array, identifiers) {
+function disassociate(ArraysCache, array, identifiers) {
   for (let i = 0; i < identifiers.length; i++) {
-    disassociateIdentifier(array, identifiers[i]);
+    disassociateIdentifier(ArraysCache, array, identifiers[i]);
   }
 }
-function disassociateIdentifier(array, identifier) {
-  let cache = RecordArraysCache.get(identifier);
+function disassociateIdentifier(ArraysCache, array, identifier) {
+  let cache = ArraysCache.get(identifier);
   if (cache) {
     cache.delete(array);
   }
 }
-function sync(array, changes) {
+function sync(array, changes, arraySet) {
   let state = array[SOURCE];
   const adds = [];
   const removes = [];
   changes.forEach((value, key) => {
     if (value === 'add') {
       // likely we want to keep a Set along-side
-      if (state.includes(key)) {
+      if (arraySet.has(key)) {
         return;
       }
       adds.push(key);
+      arraySet.add(key);
     } else {
-      if (state.includes(key)) {
+      if (arraySet.has(key)) {
         removes.push(key);
       }
     }
@@ -3294,6 +3313,7 @@ function sync(array, changes) {
   if (removes.length) {
     if (removes.length === state.length) {
       state.length = 0;
+      arraySet.clear();
       // changing the reference breaks the Proxy
       // state = array[SOURCE] = [];
     } else {
@@ -3301,6 +3321,7 @@ function sync(array, changes) {
         const index = state.indexOf(i);
         if (index !== -1) {
           state.splice(index, 1);
+          arraySet.delete(i);
         }
       });
     }
@@ -3720,17 +3741,34 @@ class Store extends EmberObject {
   _run(cb) {
     assert(`EmberData should never encounter a nested run`, !this._cbs);
     const _cbs = this._cbs = {};
-    cb();
-    if (_cbs.coalesce) {
-      _cbs.coalesce();
-    }
-    if (_cbs.sync) {
-      _cbs.sync();
-    }
-    if (_cbs.notify) {
-      _cbs.notify();
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
+      try {
+        cb();
+        if (_cbs.coalesce) {
+          _cbs.coalesce();
+        }
+        if (_cbs.sync) {
+          _cbs.sync();
+        }
+        if (_cbs.notify) {
+          _cbs.notify();
+        }
+      } finally {
+        this._cbs = null;
+      }
+    } else {
+      cb();
+      if (_cbs.coalesce) {
+        _cbs.coalesce();
+      }
+      if (_cbs.sync) {
+        _cbs.sync();
+      }
+      if (_cbs.notify) {
+        _cbs.notify();
+      }
+      this._cbs = null;
     }
-    this._cbs = null;
   }
   _join(cb) {
     if (this._cbs) {
@@ -5017,12 +5055,11 @@ class Store extends EmberObject {
         // during unload
         if (macroCondition(getOwnConfig().packages.HAS_GRAPH_PACKAGE)) {
           const peekGraph = importSync('@ember-data/graph/-private').peekGraph;
-          let graph = peekGraph(this);
+          const graph = peekGraph(this);
           if (graph) {
             graph.identifiers.clear();
           }
         }
-        this.notifications.destroy();
         this.recordArrayManager.clear();
         this._instanceCache.clear();
       } else {
@@ -5538,6 +5575,7 @@ class Store extends EmberObject {
         graph.destroy();
       }
     }
+    this.notifications.destroy();
     this.recordArrayManager.destroy();
     this.identifierCache.destroy();
     this.unloadAll();