@apollo/client 3.13.8 → 3.13.9-rc.0

package/cache/inmemory/entityStore.js

@@ -1,74 +1,35 @@
-import { __assign, __extends, __rest } from "tslib";
-import { invariant } from "../../utilities/globals/index.js";
-import { dep } from "optimism";
 import { equal } from "@wry/equality";
 import { Trie } from "@wry/trie";
-import { isReference, makeReference, DeepMerger, maybeDeepFreeze, canUseWeakMap, isNonNullObject, } from "../../utilities/index.js";
-import { hasOwn, fieldNameFromStoreName } from "./helpers.js";
-var DELETE = Object.create(null);
-var delModifier = function () { return DELETE; };
-var INVALIDATE = Object.create(null);
-var EntityStore = /** @class */ (function () {
-    function EntityStore(policies, group) {
-        var _this = this;
+import { dep } from "optimism";
+import { isReference } from "@apollo/client/utilities";
+import { __DEV__ } from "@apollo/client/utilities/environment";
+import { DeepMerger, isNonNullObject, makeReference, maybeDeepFreeze, } from "@apollo/client/utilities/internal";
+import { invariant } from "@apollo/client/utilities/invariant";
+import { fieldNameFromStoreName, hasOwn } from "./helpers.js";
+const DELETE = {};
+const delModifier = () => DELETE;
+const INVALIDATE = {};
+export class EntityStore {
+    policies;
+    group;
+    data = {};
+    constructor(policies, group) {
         this.policies = policies;
         this.group = group;
-        this.data = Object.create(null);
-        // Maps root entity IDs to the number of times they have been retained, minus
-        // the number of times they have been released. Retained entities keep other
-        // entities they reference (even indirectly) from being garbage collected.
-        this.rootIds = Object.create(null);
-        // Lazily tracks { __ref: <dataId> } strings contained by this.data[dataId].
-        this.refs = Object.create(null);
-        // Bound function that can be passed around to provide easy access to fields
-        // of Reference objects as well as ordinary objects.
-        this.getFieldValue = function (objectOrReference, storeFieldName) {
-            return maybeDeepFreeze(isReference(objectOrReference) ?
-                _this.get(objectOrReference.__ref, storeFieldName)
-                : objectOrReference && objectOrReference[storeFieldName]);
-        };
-        // Returns true for non-normalized StoreObjects and non-dangling
-        // References, indicating that readField(name, objOrRef) has a chance of
-        // working. Useful for filtering out dangling references from lists.
-        this.canRead = function (objOrRef) {
-            return isReference(objOrRef) ?
-                _this.has(objOrRef.__ref)
-                : typeof objOrRef === "object";
-        };
-        // Bound function that converts an id or an object with a __typename and
-        // primary key fields to a Reference object. If called with a Reference object,
-        // that same Reference object is returned. Pass true for mergeIntoStore to persist
-        // an object into the store.
-        this.toReference = function (objOrIdOrRef, mergeIntoStore) {
-            if (typeof objOrIdOrRef === "string") {
-                return makeReference(objOrIdOrRef);
-            }
-            if (isReference(objOrIdOrRef)) {
-                return objOrIdOrRef;
-            }
-            var id = _this.policies.identify(objOrIdOrRef)[0];
-            if (id) {
-                var ref = makeReference(id);
-                if (mergeIntoStore) {
-                    _this.merge(id, objOrIdOrRef);
-                }
-                return ref;
-            }
-        };
     }
     // Although the EntityStore class is abstract, it contains concrete
     // implementations of the various NormalizedCache interface methods that
     // are inherited by the Root and Layer subclasses.
-    EntityStore.prototype.toObject = function () {
-        return __assign({}, this.data);
-    };
-    EntityStore.prototype.has = function (dataId) {
+    toObject() {
+        return { ...this.data };
+    }
+    has(dataId) {
         return this.lookup(dataId, true) !== void 0;
-    };
-    EntityStore.prototype.get = function (dataId, fieldName) {
+    }
+    get(dataId, fieldName) {
         this.group.depend(dataId, fieldName);
         if (hasOwn.call(this.data, dataId)) {
-            var storeObject = this.data[dataId];
+            const storeObject = this.data[dataId];
             if (storeObject && hasOwn.call(storeObject, fieldName)) {
                 return storeObject[fieldName];
             }
@@ -80,8 +41,8 @@ var EntityStore = /** @class */ (function () {
         if (this instanceof Layer) {
             return this.parent.get(dataId, fieldName);
         }
-    };
-    EntityStore.prototype.lookup = function (dataId, dependOnExistence) {
+    }
+    lookup(dataId, dependOnExistence) {
         // The has method (above) calls lookup with dependOnExistence = true, so
         // that it can later be invalidated when we add or remove a StoreObject for
         // this dataId. Any consumer who cares about the contents of the StoreObject
@@ -96,45 +57,44 @@ var EntityStore = /** @class */ (function () {
             return this.parent.lookup(dataId, dependOnExistence);
         }
         if (this.policies.rootTypenamesById[dataId]) {
-            return Object.create(null);
+            return {};
         }
-    };
-    EntityStore.prototype.merge = function (older, newer) {
-        var _this = this;
-        var dataId;
+    }
+    merge(older, newer) {
+        let dataId;
         // Convert unexpected references to ID strings.
         if (isReference(older))
             older = older.__ref;
         if (isReference(newer))
             newer = newer.__ref;
-        var existing = typeof older === "string" ? this.lookup((dataId = older)) : older;
-        var incoming = typeof newer === "string" ? this.lookup((dataId = newer)) : newer;
+        const existing = typeof older === "string" ? this.lookup((dataId = older)) : older;
+        const incoming = typeof newer === "string" ? this.lookup((dataId = newer)) : newer;
         // If newer was a string ID, but that ID was not defined in this store,
         // then there are no fields to be merged, so we're done.
         if (!incoming)
             return;
-        invariant(typeof dataId === "string", 2);
-        var merged = new DeepMerger(storeObjectReconciler).merge(existing, incoming);
+        invariant(typeof dataId === "string", 97);
+        const merged = new DeepMerger(storeObjectReconciler).merge(existing, incoming);
         // Even if merged === existing, existing may have come from a lower
         // layer, so we always need to set this.data[dataId] on this level.
         this.data[dataId] = merged;
         if (merged !== existing) {
             delete this.refs[dataId];
             if (this.group.caching) {
-                var fieldsToDirty_1 = Object.create(null);
+                const fieldsToDirty = {};
                 // If we added a new StoreObject where there was previously none, dirty
                 // anything that depended on the existence of this dataId, such as the
                 // EntityStore#has method.
                 if (!existing)
-                    fieldsToDirty_1.__exists = 1;
+                    fieldsToDirty.__exists = 1;
                 // Now invalidate dependents who called getFieldValue for any fields
                 // that are changing as a result of this merge.
-                Object.keys(incoming).forEach(function (storeFieldName) {
+                Object.keys(incoming).forEach((storeFieldName) => {
                     if (!existing ||
                         existing[storeFieldName] !== merged[storeFieldName]) {
                         // Always dirty the full storeFieldName, which may include
                         // serialized arguments following the fieldName prefix.
-                        fieldsToDirty_1[storeFieldName] = 1;
+                        fieldsToDirty[storeFieldName] = 1;
                         // Also dirty fieldNameFromStoreName(storeFieldName) if it's
                         // different from storeFieldName and this field does not have
                         // keyArgs configured, because that means the cache can't make
@@ -142,78 +102,78 @@ var EntityStore = /** @class */ (function () {
                         // name but different arguments might be interrelated, so it
                         // must err on the side of invalidating all field values that
                         // share the same short fieldName, regardless of arguments.
-                        var fieldName = fieldNameFromStoreName(storeFieldName);
+                        const fieldName = fieldNameFromStoreName(storeFieldName);
                         if (fieldName !== storeFieldName &&
-                            !_this.policies.hasKeyArgs(merged.__typename, fieldName)) {
-                            fieldsToDirty_1[fieldName] = 1;
+                            !this.policies.hasKeyArgs(merged.__typename, fieldName)) {
+                            fieldsToDirty[fieldName] = 1;
                         }
                         // If merged[storeFieldName] has become undefined, and this is the
                         // Root layer, actually delete the property from the merged object,
                         // which is guaranteed to have been created fresh in this method.
-                        if (merged[storeFieldName] === void 0 && !(_this instanceof Layer)) {
+                        if (merged[storeFieldName] === void 0 && !(this instanceof Layer)) {
                             delete merged[storeFieldName];
                         }
                     }
                 });
-                if (fieldsToDirty_1.__typename &&
+                if (fieldsToDirty.__typename &&
                     !(existing && existing.__typename) &&
                     // Since we return default root __typename strings
                     // automatically from store.get, we don't need to dirty the
                     // ROOT_QUERY.__typename field if merged.__typename is equal
                     // to the default string (usually "Query").
                     this.policies.rootTypenamesById[dataId] === merged.__typename) {
-                    delete fieldsToDirty_1.__typename;
+                    delete fieldsToDirty.__typename;
                 }
-                Object.keys(fieldsToDirty_1).forEach(function (fieldName) {
-                    return _this.group.dirty(dataId, fieldName);
-                });
+                Object.keys(fieldsToDirty).forEach((fieldName) => this.group.dirty(dataId, fieldName));
             }
         }
-    };
-    EntityStore.prototype.modify = function (dataId, fields) {
-        var _this = this;
-        var storeObject = this.lookup(dataId);
+    }
+    modify(dataId, fields) {
+        const storeObject = this.lookup(dataId);
         if (storeObject) {
-            var changedFields_1 = Object.create(null);
-            var needToMerge_1 = false;
-            var allDeleted_1 = true;
-            var sharedDetails_1 = {
-                DELETE: DELETE,
-                INVALIDATE: INVALIDATE,
-                isReference: isReference,
+            const changedFields = {};
+            let needToMerge = false;
+            let allDeleted = true;
+            const sharedDetails = {
+                DELETE,
+                INVALIDATE,
+                isReference,
                 toReference: this.toReference,
                 canRead: this.canRead,
-                readField: function (fieldNameOrOptions, from) {
-                    return _this.policies.readField(typeof fieldNameOrOptions === "string" ?
-                        {
-                            fieldName: fieldNameOrOptions,
-                            from: from || makeReference(dataId),
-                        }
-                        : fieldNameOrOptions, { store: _this });
-                },
+                readField: (fieldNameOrOptions, from) => this.policies.readField(typeof fieldNameOrOptions === "string" ?
+                    {
+                        fieldName: fieldNameOrOptions,
+                        from: from || makeReference(dataId),
+                    }
+                    : fieldNameOrOptions, { store: this }),
             };
-            Object.keys(storeObject).forEach(function (storeFieldName) {
-                var fieldName = fieldNameFromStoreName(storeFieldName);
-                var fieldValue = storeObject[storeFieldName];
+            Object.keys(storeObject).forEach((storeFieldName) => {
+                const fieldName = fieldNameFromStoreName(storeFieldName);
+                let fieldValue = storeObject[storeFieldName];
                 if (fieldValue === void 0)
                     return;
-                var modify = typeof fields === "function" ? fields : (fields[storeFieldName] || fields[fieldName]);
+                const modify = typeof fields === "function" ? fields : (fields[storeFieldName] || fields[fieldName]);
                 if (modify) {
-                    var newValue = modify === delModifier ? DELETE : (modify(maybeDeepFreeze(fieldValue), __assign(__assign({}, sharedDetails_1), { fieldName: fieldName, storeFieldName: storeFieldName, storage: _this.getStorage(dataId, storeFieldName) })));
+                    let newValue = modify === delModifier ? DELETE : (modify(maybeDeepFreeze(fieldValue), {
+                        ...sharedDetails,
+                        fieldName,
+                        storeFieldName,
+                        storage: this.getStorage(dataId, storeFieldName),
+                    }));
                     if (newValue === INVALIDATE) {
-                        _this.group.dirty(dataId, storeFieldName);
+                        this.group.dirty(dataId, storeFieldName);
                     }
                     else {
                         if (newValue === DELETE)
                             newValue = void 0;
                         if (newValue !== fieldValue) {
-                            changedFields_1[storeFieldName] = newValue;
-                            needToMerge_1 = true;
+                            changedFields[storeFieldName] = newValue;
+                            needToMerge = true;
                             fieldValue = newValue;
-                            if (globalThis.__DEV__ !== false) {
-                                var checkReference = function (ref) {
-                                    if (_this.lookup(ref.__ref) === undefined) {
-                                        globalThis.__DEV__ !== false && invariant.warn(3, ref);
+                            if (__DEV__) {
+                                const checkReference = (ref) => {
+                                    if (this.lookup(ref.__ref) === undefined) {
+                                        __DEV__ && invariant.warn(98, ref);
                                         return true;
                                     }
                                 };
@@ -222,10 +182,9 @@ var EntityStore = /** @class */ (function () {
                                 }
                                 else if (Array.isArray(newValue)) {
                                     // Warn about writing "mixed" arrays of Reference and non-Reference objects
-                                    var seenReference = false;
-                                    var someNonReference = void 0;
-                                    for (var _i = 0, newValue_1 = newValue; _i < newValue_1.length; _i++) {
-                                        var value = newValue_1[_i];
+                                    let seenReference = false;
+                                    let someNonReference;
+                                    for (const value of newValue) {
                                         if (isReference(value)) {
                                             seenReference = true;
                                             if (checkReference(value))
@@ -235,7 +194,7 @@ var EntityStore = /** @class */ (function () {
                                             // Do not warn on primitive values, since those could never be represented
                                             // by a reference. This is a valid (albeit uncommon) use case.
                                             if (typeof value === "object" && !!value) {
-                                                var id = _this.policies.identify(value)[0];
+                                                const [id] = this.policies.identify(value);
                                                 // check if object could even be referenced, otherwise we are not interested in it for this warning
                                                 if (id) {
                                                     someNonReference = value;
@@ -243,7 +202,7 @@ var EntityStore = /** @class */ (function () {
                                             }
                                         }
                                         if (seenReference && someNonReference !== undefined) {
-                                            globalThis.__DEV__ !== false && invariant.warn(4, someNonReference);
+                                            __DEV__ && invariant.warn(99, someNonReference);
                                             break;
                                         }
                                     }
@@ -253,12 +212,12 @@ var EntityStore = /** @class */ (function () {
                     }
                 }
                 if (fieldValue !== void 0) {
-                    allDeleted_1 = false;
+                    allDeleted = false;
                 }
             });
-            if (needToMerge_1) {
-                this.merge(dataId, changedFields_1);
-                if (allDeleted_1) {
+            if (needToMerge) {
+                this.merge(dataId, changedFields);
+                if (allDeleted) {
                     if (this instanceof Layer) {
                         this.data[dataId] = void 0;
                     }
@@ -271,29 +230,30 @@ var EntityStore = /** @class */ (function () {
             }
         }
         return false;
-    };
+    }
     // If called with only one argument, removes the entire entity
     // identified by dataId. If called with a fieldName as well, removes all
     // fields of that entity whose names match fieldName according to the
     // fieldNameFromStoreName helper function. If called with a fieldName
     // and variables, removes all fields of that entity whose names match fieldName
     // and whose arguments when cached exactly match the variables passed.
-    EntityStore.prototype.delete = function (dataId, fieldName, args) {
-        var _a;
-        var storeObject = this.lookup(dataId);
+    delete(dataId, fieldName, args) {
+        const storeObject = this.lookup(dataId);
         if (storeObject) {
-            var typename = this.getFieldValue(storeObject, "__typename");
-            var storeFieldName = fieldName && args ?
-                this.policies.getStoreFieldName({ typename: typename, fieldName: fieldName, args: args })
+            const typename = this.getFieldValue(storeObject, "__typename");
+            const storeFieldName = fieldName && args ?
+                this.policies.getStoreFieldName({ typename, fieldName, args })
                 : fieldName;
-            return this.modify(dataId, storeFieldName ? (_a = {},
-                _a[storeFieldName] = delModifier,
-                _a) : delModifier);
+            return this.modify(dataId, storeFieldName ?
+                {
+                    [storeFieldName]: delModifier,
+                }
+                : delModifier);
         }
         return false;
-    };
-    EntityStore.prototype.evict = function (options, limit) {
-        var evicted = false;
+    }
+    evict(options, limit) {
+        let evicted = false;
         if (options.id) {
             if (hasOwn.call(this.data, options.id)) {
                 evicted = this.delete(options.id, options.fieldName, options.args);
@@ -310,16 +270,15 @@ var EntityStore = /** @class */ (function () {
             }
         }
         return evicted;
-    };
-    EntityStore.prototype.clear = function () {
+    }
+    clear() {
         this.replace(null);
-    };
-    EntityStore.prototype.extract = function () {
-        var _this = this;
-        var obj = this.toObject();
-        var extraRootIds = [];
-        this.getRootIdSet().forEach(function (id) {
-            if (!hasOwn.call(_this.policies.rootTypenamesById, id)) {
+    }
+    extract() {
+        const obj = this.toObject();
+        const extraRootIds = [];
+        this.getRootIdSet().forEach((id) => {
+            if (!hasOwn.call(this.policies.rootTypenamesById, id)) {
                 extraRootIds.push(id);
             }
         });
@@ -327,40 +286,42 @@ var EntityStore = /** @class */ (function () {
             obj.__META = { extraRootIds: extraRootIds.sort() };
         }
         return obj;
-    };
-    EntityStore.prototype.replace = function (newData) {
-        var _this = this;
-        Object.keys(this.data).forEach(function (dataId) {
+    }
+    replace(newData) {
+        Object.keys(this.data).forEach((dataId) => {
             if (!(newData && hasOwn.call(newData, dataId))) {
-                _this.delete(dataId);
+                this.delete(dataId);
             }
         });
         if (newData) {
-            var __META = newData.__META, rest_1 = __rest(newData, ["__META"]);
-            Object.keys(rest_1).forEach(function (dataId) {
-                _this.merge(dataId, rest_1[dataId]);
+            const { __META, ...rest } = newData;
+            Object.keys(rest).forEach((dataId) => {
+                this.merge(dataId, rest[dataId]);
             });
             if (__META) {
                 __META.extraRootIds.forEach(this.retain, this);
             }
         }
-    };
-    EntityStore.prototype.retain = function (rootId) {
+    }
+    // Maps root entity IDs to the number of times they have been retained, minus
+    // the number of times they have been released. Retained entities keep other
+    // entities they reference (even indirectly) from being garbage collected.
+    rootIds = {};
+    retain(rootId) {
         return (this.rootIds[rootId] = (this.rootIds[rootId] || 0) + 1);
-    };
-    EntityStore.prototype.release = function (rootId) {
+    }
+    release(rootId) {
         if (this.rootIds[rootId] > 0) {
-            var count = --this.rootIds[rootId];
+            const count = --this.rootIds[rootId];
             if (!count)
                 delete this.rootIds[rootId];
             return count;
         }
         return 0;
-    };
+    }
     // Return a Set<string> of all the ID strings that have been retained by
     // this layer/root *and* any layers/roots beneath it.
-    EntityStore.prototype.getRootIdSet = function (ids) {
-        if (ids === void 0) { ids = new Set(); }
+    getRootIdSet(ids = new Set()) {
         Object.keys(this.rootIds).forEach(ids.add, ids);
         if (this instanceof Layer) {
             this.parent.getRootIdSet(ids);
@@ -372,47 +333,48 @@ var EntityStore = /** @class */ (function () {
             Object.keys(this.policies.rootTypenamesById).forEach(ids.add, ids);
         }
         return ids;
-    };
+    }
     // The goal of garbage collection is to remove IDs from the Root layer of the
     // store that are no longer reachable starting from any IDs that have been
     // explicitly retained (see retain and release, above). Returns an array of
     // dataId strings that were removed from the store.
-    EntityStore.prototype.gc = function () {
-        var _this = this;
-        var ids = this.getRootIdSet();
-        var snapshot = this.toObject();
-        ids.forEach(function (id) {
+    gc() {
+        const ids = this.getRootIdSet();
+        const snapshot = this.toObject();
+        ids.forEach((id) => {
             if (hasOwn.call(snapshot, id)) {
                 // Because we are iterating over an ECMAScript Set, the IDs we add here
                 // will be visited in later iterations of the forEach loop only if they
                 // were not previously contained by the Set.
-                Object.keys(_this.findChildRefIds(id)).forEach(ids.add, ids);
+                Object.keys(this.findChildRefIds(id)).forEach(ids.add, ids);
                 // By removing IDs from the snapshot object here, we protect them from
                 // getting removed from the root store layer below.
                 delete snapshot[id];
             }
         });
-        var idsToRemove = Object.keys(snapshot);
+        const idsToRemove = Object.keys(snapshot);
         if (idsToRemove.length) {
-            var root_1 = this;
-            while (root_1 instanceof Layer)
-                root_1 = root_1.parent;
-            idsToRemove.forEach(function (id) { return root_1.delete(id); });
+            let root = this;
+            while (root instanceof Layer)
+                root = root.parent;
+            idsToRemove.forEach((id) => root.delete(id));
         }
         return idsToRemove;
-    };
-    EntityStore.prototype.findChildRefIds = function (dataId) {
+    }
+    // Lazily tracks { __ref: <dataId> } strings contained by this.data[dataId].
+    refs = {};
+    findChildRefIds(dataId) {
         if (!hasOwn.call(this.refs, dataId)) {
-            var found_1 = (this.refs[dataId] = Object.create(null));
-            var root = this.data[dataId];
+            const found = (this.refs[dataId] = {});
+            const root = this.data[dataId];
             if (!root)
-                return found_1;
-            var workSet_1 = new Set([root]);
+                return found;
+            const workSet = new Set([root]);
             // Within the store, only arrays and objects can contain child entity
             // references, so we can prune the traversal using this predicate:
-            workSet_1.forEach(function (obj) {
+            workSet.forEach((obj) => {
                 if (isReference(obj)) {
-                    found_1[obj.__ref] = true;
+                    found[obj.__ref] = true;
                     // In rare cases, a { __ref } Reference object may have other fields.
                     // This often indicates a mismerging of References with StoreObjects,
                     // but garbage collection should not be fooled by a stray __ref
@@ -422,25 +384,59 @@ var EntityStore = /** @class */ (function () {
                     // to the code below, which will handle any other properties of obj.
                 }
                 if (isNonNullObject(obj)) {
-                    Object.keys(obj).forEach(function (key) {
-                        var child = obj[key];
+                    Object.keys(obj).forEach((key) => {
+                        const child = obj[key];
                         // No need to add primitive values to the workSet, since they cannot
                         // contain reference objects.
                         if (isNonNullObject(child)) {
-                            workSet_1.add(child);
+                            workSet.add(child);
                         }
                     });
                 }
             });
         }
         return this.refs[dataId];
-    };
-    EntityStore.prototype.makeCacheKey = function () {
+    }
+    makeCacheKey() {
         return this.group.keyMaker.lookupArray(arguments);
+    }
+    // Bound function that can be passed around to provide easy access to fields
+    // of Reference objects as well as ordinary objects.
+    getFieldValue = (objectOrReference, storeFieldName) => maybeDeepFreeze(isReference(objectOrReference) ?
+        this.get(objectOrReference.__ref, storeFieldName)
+        : objectOrReference && objectOrReference[storeFieldName]);
+    // Returns true for non-normalized StoreObjects and non-dangling
+    // References, indicating that readField(name, objOrRef) has a chance of
+    // working. Useful for filtering out dangling references from lists.
+    canRead = (objOrRef) => {
+        return isReference(objOrRef) ?
+            this.has(objOrRef.__ref)
+            : typeof objOrRef === "object";
     };
-    return EntityStore;
-}());
-export { EntityStore };
+    // Bound function that converts an id or an object with a __typename and
+    // primary key fields to a Reference object. If called with a Reference object,
+    // that same Reference object is returned. Pass true for mergeIntoStore to persist
+    // an object into the store.
+    toReference = (objOrIdOrRef, mergeIntoStore) => {
+        if (typeof objOrIdOrRef === "string") {
+            return makeReference(objOrIdOrRef);
+        }
+        if (isReference(objOrIdOrRef)) {
+            return objOrIdOrRef;
+        }
+        const [id] = this.policies.identify(objOrIdOrRef);
+        if (id) {
+            const ref = makeReference(id);
+            if (mergeIntoStore) {
+                this.merge(id, objOrIdOrRef);
+            }
+            return ref;
+        }
+    };
+    get supportsResultCaching() {
+        return this.group.caching;
+    }
+}
 // A single CacheGroup represents a set of one or more EntityStore objects,
 // typically the Root store in a CacheGroup by itself, and all active Layer
 // stores in a group together. A single EntityStore object belongs to only
@@ -454,22 +450,26 @@ export { EntityStore };
 // belong to one CacheGroup, with the non-optimistic Root object belonging
 // to another CacheGroup, allowing resultCaching dependencies to be tracked
 // separately for optimistic and non-optimistic entity data.
-var CacheGroup = /** @class */ (function () {
-    function CacheGroup(caching, parent) {
-        if (parent === void 0) { parent = null; }
+class CacheGroup {
+    caching;
+    parent;
+    d = null;
+    // Used by the EntityStore#makeCacheKey method to compute cache keys
+    // specific to this CacheGroup.
+    keyMaker;
+    constructor(caching, parent = null) {
         this.caching = caching;
         this.parent = parent;
-        this.d = null;
         this.resetCaching();
     }
-    CacheGroup.prototype.resetCaching = function () {
+    resetCaching() {
         this.d = this.caching ? dep() : null;
-        this.keyMaker = new Trie(canUseWeakMap);
-    };
-    CacheGroup.prototype.depend = function (dataId, storeFieldName) {
+        this.keyMaker = new Trie();
+    }
+    depend(dataId, storeFieldName) {
         if (this.d) {
             this.d(makeDepKey(dataId, storeFieldName));
-            var fieldName = fieldNameFromStoreName(storeFieldName);
+            const fieldName = fieldNameFromStoreName(storeFieldName);
             if (fieldName !== storeFieldName) {
                 // Fields with arguments that contribute extra identifying
                 // information to the fieldName (thus forming the storeFieldName)
@@ -482,8 +482,8 @@ var CacheGroup = /** @class */ (function () {
                 this.parent.depend(dataId, storeFieldName);
             }
         }
-    };
-    CacheGroup.prototype.dirty = function (dataId, storeFieldName) {
+    }
+    dirty(dataId, storeFieldName) {
         if (this.d) {
             this.d.dirty(makeDepKey(dataId, storeFieldName), 
             // When storeFieldName === "__exists", that means the entity identified
@@ -495,9 +495,8 @@ var CacheGroup = /** @class */ (function () {
             // details, see https://github.com/benjamn/optimism/pull/195.
             storeFieldName === "__exists" ? "forget" : "setDirty");
         }
-    };
-    return CacheGroup;
-}());
+    }
+}
 function makeDepKey(dataId, storeFieldName) {
     // Since field names cannot have '#' characters in them, this method
     // of joining the field name and the ID should be unambiguous, and much
@@ -519,88 +518,85 @@ export function maybeDependOnExistenceOfEntity(store, entityId) {
 }
 (function (EntityStore) {
     // Refer to this class as EntityStore.Root outside this namespace.
-    var Root = /** @class */ (function (_super) {
-        __extends(Root, _super);
-        function Root(_a) {
-            var policies = _a.policies, _b = _a.resultCaching, resultCaching = _b === void 0 ? true : _b, seed = _a.seed;
-            var _this = _super.call(this, policies, new CacheGroup(resultCaching)) || this;
-            _this.stump = new Stump(_this);
-            _this.storageTrie = new Trie(canUseWeakMap);
+    class Root extends EntityStore {
+        constructor({ policies, resultCaching = true, seed, }) {
+            super(policies, new CacheGroup(resultCaching));
             if (seed)
-                _this.replace(seed);
-            return _this;
+                this.replace(seed);
         }
-        Root.prototype.addLayer = function (layerId, replay) {
+        stump = new Stump(this);
+        addLayer(layerId, replay) {
             // Adding an optimistic Layer on top of the Root actually adds the Layer
             // on top of the Stump, so the Stump always comes between the Root and
             // any Layer objects that we've added.
             return this.stump.addLayer(layerId, replay);
-        };
-        Root.prototype.removeLayer = function () {
+        }
+        removeLayer() {
             // Never remove the root layer.
             return this;
-        };
-        Root.prototype.getStorage = function () {
+        }
+        storageTrie = new Trie();
+        getStorage() {
             return this.storageTrie.lookupArray(arguments);
-        };
-        return Root;
-    }(EntityStore));
+        }
+    }
     EntityStore.Root = Root;
 })(EntityStore || (EntityStore = {}));
 // Not exported, since all Layer instances are created by the addLayer method
 // of the EntityStore.Root class.
-var Layer = /** @class */ (function (_super) {
-    __extends(Layer, _super);
-    function Layer(id, parent, replay, group) {
-        var _this = _super.call(this, parent.policies, group) || this;
-        _this.id = id;
-        _this.parent = parent;
-        _this.replay = replay;
-        _this.group = group;
-        replay(_this);
-        return _this;
-    }
-    Layer.prototype.addLayer = function (layerId, replay) {
+class Layer extends EntityStore {
+    id;
+    parent;
+    replay;
+    group;
+    constructor(id, parent, replay, group) {
+        super(parent.policies, group);
+        this.id = id;
+        this.parent = parent;
+        this.replay = replay;
+        this.group = group;
+        replay(this);
+    }
+    addLayer(layerId, replay) {
         return new Layer(layerId, this, replay, this.group);
-    };
-    Layer.prototype.removeLayer = function (layerId) {
-        var _this = this;
+    }
+    removeLayer(layerId) {
         // Remove all instances of the given id, not just the first one.
-        var parent = this.parent.removeLayer(layerId);
+        const parent = this.parent.removeLayer(layerId);
         if (layerId === this.id) {
             if (this.group.caching) {
                 // Dirty every ID we're removing. Technically we might be able to avoid
                 // dirtying fields that have values in higher layers, but we don't have
                 // easy access to higher layers here, and we're about to recreate those
                 // layers anyway (see parent.addLayer below).
-                Object.keys(this.data).forEach(function (dataId) {
-                    var ownStoreObject = _this.data[dataId];
-                    var parentStoreObject = parent["lookup"](dataId);
+                Object.keys(this.data).forEach((dataId) => {
+                    const ownStoreObject = this.data[dataId];
+                    const parentStoreObject = parent["lookup"](dataId);
                     if (!parentStoreObject) {
                         // The StoreObject identified by dataId was defined in this layer
                         // but will be undefined in the parent layer, so we can delete the
                         // whole entity using this.delete(dataId). Since we're about to
                         // throw this layer away, the only goal of this deletion is to dirty
                         // the removed fields.
-                        _this.delete(dataId);
+                        this.delete(dataId);
                     }
                     else if (!ownStoreObject) {
                         // This layer had an entry for dataId but it was undefined, which
                         // means the entity was deleted in this layer, and it's about to
                         // become undeleted when we remove this layer, so we need to dirty
                         // all fields that are about to be reexposed.
-                        _this.group.dirty(dataId, "__exists");
-                        Object.keys(parentStoreObject).forEach(function (storeFieldName) {
-                            _this.group.dirty(dataId, storeFieldName);
+                        this.group.dirty(dataId, "__exists");
+                        Object.keys(parentStoreObject).forEach((storeFieldName) => {
+                            this.group.dirty(dataId, storeFieldName);
                         });
                     }
                     else if (ownStoreObject !== parentStoreObject) {
                         // If ownStoreObject is not exactly the same as parentStoreObject,
                         // dirty any fields whose values will change as a result of this
                         // removal.
-                        Object.keys(ownStoreObject).forEach(function (storeFieldName) {
+                        Object.keys(ownStoreObject).forEach((storeFieldName) => {
                             if (!equal(ownStoreObject[storeFieldName], parentStoreObject[storeFieldName])) {
-                                _this.group.dirty(dataId, storeFieldName);
+                                this.group.dirty(dataId, storeFieldName);
                             }
                         });
                     }
@@ -613,50 +609,53 @@ var Layer = /** @class */ (function (_super) {
             return this;
         // Recreate this layer on top of the new parent.
         return parent.addLayer(this.id, this.replay);
-    };
-    Layer.prototype.toObject = function () {
-        return __assign(__assign({}, this.parent.toObject()), this.data);
-    };
-    Layer.prototype.findChildRefIds = function (dataId) {
-        var fromParent = this.parent.findChildRefIds(dataId);
-        return hasOwn.call(this.data, dataId) ? __assign(__assign({}, fromParent), _super.prototype.findChildRefIds.call(this, dataId)) : fromParent;
-    };
-    Layer.prototype.getStorage = function () {
-        var p = this.parent;
+    }
+    toObject() {
+        return {
+            ...this.parent.toObject(),
+            ...this.data,
+        };
+    }
+    findChildRefIds(dataId) {
+        const fromParent = this.parent.findChildRefIds(dataId);
+        return hasOwn.call(this.data, dataId) ?
+            {
+                ...fromParent,
+                ...super.findChildRefIds(dataId),
+            }
+            : fromParent;
+    }
+    getStorage(...args) {
+        let p = this.parent;
         while (p.parent)
             p = p.parent;
-        return p.getStorage.apply(p, 
-        // @ts-expect-error
-        arguments);
-    };
-    return Layer;
-}(EntityStore));
+        return p.getStorage(...args);
+    }
+}
 // Represents a Layer permanently installed just above the Root, which allows
 // reading optimistically (and registering optimistic dependencies) even when
 // no optimistic layers are currently active. The stump.group CacheGroup object
 // is shared by any/all Layer objects added on top of the Stump.
-var Stump = /** @class */ (function (_super) {
-    __extends(Stump, _super);
-    function Stump(root) {
-        return _super.call(this, "EntityStore.Stump", root, function () { }, new CacheGroup(root.group.caching, root.group)) || this;
+class Stump extends Layer {
+    constructor(root) {
+        super("EntityStore.Stump", root, () => { }, new CacheGroup(root.group.caching, root.group));
     }
-    Stump.prototype.removeLayer = function () {
+    removeLayer() {
         // Never remove the Stump layer.
         return this;
-    };
-    Stump.prototype.merge = function (older, newer) {
+    }
+    merge(older, newer) {
         // We never want to write any data into the Stump, so we forward any merge
         // calls to the Root instead. Another option here would be to throw an
         // exception, but the toReference(object, true) function can sometimes
         // trigger Stump writes (which used to be Root writes, before the Stump
         // concept was introduced).
         return this.parent.merge(older, newer);
-    };
-    return Stump;
-}(Layer));
+    }
+}
 function storeObjectReconciler(existingObject, incomingObject, property) {
-    var existingValue = existingObject[property];
-    var incomingValue = incomingObject[property];
+    const existingValue = existingObject[property];
+    const incomingValue = incomingObject[property];
     // Wherever there is a key collision, prefer the incoming value, unless
     // it is deeply equal to the existing value. It's worth checking deep
     // equality here (even though blindly returning incoming would be
@@ -666,6 +665,6 @@ function storeObjectReconciler(existingObject, incomingObject, property) {
 }
 export function supportsResultCaching(store) {
     // When result caching is disabled, store.depend will be null.
-    return !!(store instanceof EntityStore && store.group.caching);
+    return !!(store && store.supportsResultCaching);
 }
-//# sourceMappingURL=entityStore.js.map
+//# sourceMappingURL=entityStore.js.map