react-easy-wall 2.0.0 → 2.0.3

package/dist/cjs/node_modules/@apollo/client/cache/inmemory/entityStore.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"entityStore.cjs","sources":["../../../../../../../node_modules/@apollo/client/cache/inmemory/entityStore.js"],"sourcesContent":["import { equal } from \"@wry/equality\";\nimport { Trie } from \"@wry/trie\";\nimport { dep } from \"optimism\";\nimport { isReference } from \"@apollo/client/utilities\";\nimport { __DEV__ } from \"@apollo/client/utilities/environment\";\nimport { DeepMerger, isNonNullObject, makeReference, maybeDeepFreeze, } from \"@apollo/client/utilities/internal\";\nimport { invariant } from \"@apollo/client/utilities/invariant\";\nimport { fieldNameFromStoreName, hasOwn } from \"./helpers.js\";\nconst DELETE = {};\nconst delModifier = () => DELETE;\nconst INVALIDATE = {};\nexport class EntityStore {\n    policies;\n    group;\n    data = {};\n    constructor(policies, group) {\n        this.policies = policies;\n        this.group = group;\n    }\n    // Although the EntityStore class is abstract, it contains concrete\n    // implementations of the various NormalizedCache interface methods that\n    // are inherited by the Root and Layer subclasses.\n    toObject() {\n        return { ...this.data };\n    }\n    has(dataId) {\n        return this.lookup(dataId, true) !== void 0;\n    }\n    get(dataId, fieldName) {\n        this.group.depend(dataId, fieldName);\n        if (hasOwn.call(this.data, dataId)) {\n            const storeObject = this.data[dataId];\n            if (storeObject && hasOwn.call(storeObject, fieldName)) {\n                return storeObject[fieldName];\n            }\n        }\n        if (fieldName === \"__typename\" &&\n            hasOwn.call(this.policies.rootTypenamesById, dataId)) {\n            return this.policies.rootTypenamesById[dataId];\n        }\n        if (this instanceof Layer) {\n            return this.parent.get(dataId, fieldName);\n        }\n    }\n    lookup(dataId, dependOnExistence) {\n        // The has method (above) calls lookup with dependOnExistence = true, so\n        // that it can later be invalidated when we add or remove a StoreObject for\n        // this dataId. Any consumer who cares about the contents of the StoreObject\n        // should not rely on this dependency, since the contents could change\n        // without the object being added or removed.\n        if (dependOnExistence)\n            this.group.depend(dataId, \"__exists\");\n        if (hasOwn.call(this.data, dataId)) {\n            return this.data[dataId];\n        }\n        if (this instanceof Layer) {\n            return this.parent.lookup(dataId, dependOnExistence);\n        }\n        if (this.policies.rootTypenamesById[dataId]) {\n            return {};\n        }\n    }\n    merge(older, newer) {\n        let dataId;\n        // Convert unexpected references to ID strings.\n        if (isReference(older))\n            older = older.__ref;\n        if (isReference(newer))\n            newer = newer.__ref;\n        const existing = typeof older === \"string\" ? this.lookup((dataId = older)) : older;\n        const incoming = typeof newer === \"string\" ? this.lookup((dataId = newer)) : newer;\n        // If newer was a string ID, but that ID was not defined in this store,\n        // then there are no fields to be merged, so we're done.\n        if (!incoming)\n            return;\n        invariant(typeof dataId === \"string\", 99);\n        const merged = new DeepMerger({\n            reconciler: storeObjectReconciler,\n        }).merge(existing, incoming);\n        // Even if merged === existing, existing may have come from a lower\n        // layer, so we always need to set this.data[dataId] on this level.\n        this.data[dataId] = merged;\n        if (merged !== existing) {\n            delete this.refs[dataId];\n            if (this.group.caching) {\n                const fieldsToDirty = {};\n                // If we added a new StoreObject where there was previously none, dirty\n                // anything that depended on the existence of this dataId, such as the\n                // EntityStore#has method.\n                if (!existing)\n                    fieldsToDirty.__exists = 1;\n                // Now invalidate dependents who called getFieldValue for any fields\n                // that are changing as a result of this merge.\n                Object.keys(incoming).forEach((storeFieldName) => {\n                    if (!existing ||\n                        existing[storeFieldName] !== merged[storeFieldName]) {\n                        // Always dirty the full storeFieldName, which may include\n                        // serialized arguments following the fieldName prefix.\n                        fieldsToDirty[storeFieldName] = 1;\n                        // Also dirty fieldNameFromStoreName(storeFieldName) if it's\n                        // different from storeFieldName and this field does not have\n                        // keyArgs configured, because that means the cache can't make\n                        // any assumptions about how field values with the same field\n                        // name but different arguments might be interrelated, so it\n                        // must err on the side of invalidating all field values that\n                        // share the same short fieldName, regardless of arguments.\n                        const fieldName = fieldNameFromStoreName(storeFieldName);\n                        if (fieldName !== storeFieldName &&\n                            !this.policies.hasKeyArgs(merged.__typename, fieldName)) {\n                            fieldsToDirty[fieldName] = 1;\n                        }\n                        // If merged[storeFieldName] has become undefined, and this is the\n                        // Root layer, actually delete the property from the merged object,\n                        // which is guaranteed to have been created fresh in this method.\n                        if (merged[storeFieldName] === void 0 && !(this instanceof Layer)) {\n                            delete merged[storeFieldName];\n                        }\n                    }\n                });\n                if (fieldsToDirty.__typename &&\n                    !(existing && existing.__typename) &&\n                    // Since we return default root __typename strings\n                    // automatically from store.get, we don't need to dirty the\n                    // ROOT_QUERY.__typename field if merged.__typename is equal\n                    // to the default string (usually \"Query\").\n                    this.policies.rootTypenamesById[dataId] === merged.__typename) {\n                    delete fieldsToDirty.__typename;\n                }\n                Object.keys(fieldsToDirty).forEach((fieldName) => this.group.dirty(dataId, fieldName));\n            }\n        }\n    }\n    modify(dataId, fields, exact) {\n        const storeObject = this.lookup(dataId);\n        if (storeObject) {\n            const changedFields = {};\n            let needToMerge = false;\n            let allDeleted = true;\n            const sharedDetails = {\n                DELETE,\n                INVALIDATE,\n                isReference,\n                toReference: this.toReference,\n                canRead: this.canRead,\n                readField: (fieldNameOrOptions, from) => this.policies.readField(typeof fieldNameOrOptions === \"string\" ?\n                    {\n                        fieldName: fieldNameOrOptions,\n                        from: from || makeReference(dataId),\n                    }\n                    : fieldNameOrOptions, { store: this }),\n            };\n            Object.keys(storeObject).forEach((storeFieldName) => {\n                const fieldName = fieldNameFromStoreName(storeFieldName);\n                let fieldValue = storeObject[storeFieldName];\n                if (fieldValue === void 0)\n                    return;\n                const modify = typeof fields === \"function\" ? fields : (fields[storeFieldName] || (exact ? undefined : fields[fieldName]));\n                if (modify) {\n                    let newValue = modify === delModifier ? DELETE : (modify(maybeDeepFreeze(fieldValue), {\n                        ...sharedDetails,\n                        fieldName,\n                        storeFieldName,\n                        storage: this.getStorage(dataId, storeFieldName),\n                    }));\n                    if (newValue === INVALIDATE) {\n                        this.group.dirty(dataId, storeFieldName);\n                    }\n                    else {\n                        if (newValue === DELETE)\n                            newValue = void 0;\n                        if (newValue !== fieldValue) {\n                            changedFields[storeFieldName] = newValue;\n                            needToMerge = true;\n                            fieldValue = newValue;\n                            if (__DEV__) {\n                                const checkReference = (ref) => {\n                                    if (this.lookup(ref.__ref) === undefined) {\n                                        __DEV__ && invariant.warn(100, ref);\n                                        return true;\n                                    }\n                                };\n                                if (isReference(newValue)) {\n                                    checkReference(newValue);\n                                }\n                                else if (Array.isArray(newValue)) {\n                                    // Warn about writing \"mixed\" arrays of Reference and non-Reference objects\n                                    let seenReference = false;\n                                    let someNonReference;\n                                    for (const value of newValue) {\n                                        if (isReference(value)) {\n                                            seenReference = true;\n                                            if (checkReference(value))\n                                                break;\n                                        }\n                                        else {\n                                            // Do not warn on primitive values, since those could never be represented\n                                            // by a reference. This is a valid (albeit uncommon) use case.\n                                            if (typeof value === \"object\" && !!value) {\n                                                const [id] = this.policies.identify(value);\n                                                // check if object could even be referenced, otherwise we are not interested in it for this warning\n                                                if (id) {\n                                                    someNonReference = value;\n                                                }\n                                            }\n                                        }\n                                        if (seenReference && someNonReference !== undefined) {\n                                            __DEV__ && invariant.warn(101, someNonReference);\n                                            break;\n                                        }\n                                    }\n                                }\n                            }\n                        }\n                    }\n                }\n                if (fieldValue !== void 0) {\n                    allDeleted = false;\n                }\n            });\n            if (needToMerge) {\n                this.merge(dataId, changedFields);\n                if (allDeleted) {\n                    if (this instanceof Layer) {\n                        this.data[dataId] = void 0;\n                    }\n                    else {\n                        delete this.data[dataId];\n                    }\n                    this.group.dirty(dataId, \"__exists\");\n                }\n                return true;\n            }\n        }\n        return false;\n    }\n    // If called with only one argument, removes the entire entity\n    // identified by dataId. If called with a fieldName as well, removes all\n    // fields of that entity whose names match fieldName according to the\n    // fieldNameFromStoreName helper function. If called with a fieldName\n    // and variables, removes all fields of that entity whose names match fieldName\n    // and whose arguments when cached exactly match the variables passed.\n    delete(dataId, fieldName, args) {\n        const storeObject = this.lookup(dataId);\n        if (storeObject) {\n            const typename = this.getFieldValue(storeObject, \"__typename\");\n            const storeFieldName = fieldName && args ?\n                this.policies.getStoreFieldName({ typename, fieldName, args })\n                : fieldName;\n            return this.modify(dataId, storeFieldName ?\n                {\n                    [storeFieldName]: delModifier,\n                }\n                : delModifier, !!args);\n        }\n        return false;\n    }\n    evict(options, limit) {\n        let evicted = false;\n        if (options.id) {\n            if (hasOwn.call(this.data, options.id)) {\n                evicted = this.delete(options.id, options.fieldName, options.args);\n            }\n            if (this instanceof Layer && this !== limit) {\n                evicted = this.parent.evict(options, limit) || evicted;\n            }\n            // Always invalidate the field to trigger rereading of watched\n            // queries, even if no cache data was modified by the eviction,\n            // because queries may depend on computed fields with custom read\n            // functions, whose values are not stored in the EntityStore.\n            if (options.fieldName || evicted) {\n                this.group.dirty(options.id, options.fieldName || \"__exists\");\n            }\n        }\n        return evicted;\n    }\n    clear() {\n        this.replace(null);\n    }\n    extract() {\n        const obj = this.toObject();\n        const extraRootIds = [];\n        this.getRootIdSet().forEach((id) => {\n            if (!hasOwn.call(this.policies.rootTypenamesById, id)) {\n                extraRootIds.push(id);\n            }\n        });\n        if (extraRootIds.length) {\n            obj.__META = { extraRootIds: extraRootIds.sort() };\n        }\n        return obj;\n    }\n    replace(newData) {\n        Object.keys(this.data).forEach((dataId) => {\n            if (!(newData && hasOwn.call(newData, dataId))) {\n                this.delete(dataId);\n            }\n        });\n        if (newData) {\n            const { __META, ...rest } = newData;\n            Object.keys(rest).forEach((dataId) => {\n                this.merge(dataId, rest[dataId]);\n            });\n            if (__META) {\n                __META.extraRootIds.forEach(this.retain, this);\n            }\n        }\n    }\n    // Maps root entity IDs to the number of times they have been retained, minus\n    // the number of times they have been released. Retained entities keep other\n    // entities they reference (even indirectly) from being garbage collected.\n    rootIds = {};\n    retain(rootId) {\n        return (this.rootIds[rootId] = (this.rootIds[rootId] || 0) + 1);\n    }\n    release(rootId) {\n        if (this.rootIds[rootId] > 0) {\n            const count = --this.rootIds[rootId];\n            if (!count)\n                delete this.rootIds[rootId];\n            return count;\n        }\n        return 0;\n    }\n    // Return a Set<string> of all the ID strings that have been retained by\n    // this layer/root *and* any layers/roots beneath it.\n    getRootIdSet(ids = new Set()) {\n        Object.keys(this.rootIds).forEach(ids.add, ids);\n        if (this instanceof Layer) {\n            this.parent.getRootIdSet(ids);\n        }\n        else {\n            // Official singleton IDs like ROOT_QUERY and ROOT_MUTATION are\n            // always considered roots for garbage collection, regardless of\n            // their retainment counts in this.rootIds.\n            Object.keys(this.policies.rootTypenamesById).forEach(ids.add, ids);\n        }\n        return ids;\n    }\n    // The goal of garbage collection is to remove IDs from the Root layer of the\n    // store that are no longer reachable starting from any IDs that have been\n    // explicitly retained (see retain and release, above). Returns an array of\n    // dataId strings that were removed from the store.\n    gc() {\n        const ids = this.getRootIdSet();\n        const snapshot = this.toObject();\n        ids.forEach((id) => {\n            if (hasOwn.call(snapshot, id)) {\n                // Because we are iterating over an ECMAScript Set, the IDs we add here\n                // will be visited in later iterations of the forEach loop only if they\n                // were not previously contained by the Set.\n                Object.keys(this.findChildRefIds(id)).forEach(ids.add, ids);\n                // By removing IDs from the snapshot object here, we protect them from\n                // getting removed from the root store layer below.\n                delete snapshot[id];\n            }\n        });\n        const idsToRemove = Object.keys(snapshot);\n        if (idsToRemove.length) {\n            let root = this;\n            while (root instanceof Layer)\n                root = root.parent;\n            idsToRemove.forEach((id) => root.delete(id));\n        }\n        return idsToRemove;\n    }\n    // Lazily tracks { __ref: <dataId> } strings contained by this.data[dataId].\n    refs = {};\n    findChildRefIds(dataId) {\n        if (!hasOwn.call(this.refs, dataId)) {\n            const found = (this.refs[dataId] = {});\n            const root = this.data[dataId];\n            if (!root)\n                return found;\n            const workSet = new Set([root]);\n            // Within the store, only arrays and objects can contain child entity\n            // references, so we can prune the traversal using this predicate:\n            workSet.forEach((obj) => {\n                if (isReference(obj)) {\n                    found[obj.__ref] = true;\n                    // In rare cases, a { __ref } Reference object may have other fields.\n                    // This often indicates a mismerging of References with StoreObjects,\n                    // but garbage collection should not be fooled by a stray __ref\n                    // property in a StoreObject (ignoring all the other fields just\n                    // because the StoreObject looks like a Reference). To avoid this\n                    // premature termination of findChildRefIds recursion, we fall through\n                    // to the code below, which will handle any other properties of obj.\n                }\n                if (isNonNullObject(obj)) {\n                    Object.keys(obj).forEach((key) => {\n                        const child = obj[key];\n                        // No need to add primitive values to the workSet, since they cannot\n                        // contain reference objects.\n                        if (isNonNullObject(child)) {\n                            workSet.add(child);\n                        }\n                    });\n                }\n            });\n        }\n        return this.refs[dataId];\n    }\n    makeCacheKey() {\n        return this.group.keyMaker.lookupArray(arguments);\n    }\n    // Bound function that can be passed around to provide easy access to fields\n    // of Reference objects as well as ordinary objects.\n    getFieldValue = (objectOrReference, storeFieldName) => maybeDeepFreeze(isReference(objectOrReference) ?\n        this.get(objectOrReference.__ref, storeFieldName)\n        : objectOrReference && objectOrReference[storeFieldName]);\n    // Returns true for non-normalized StoreObjects and non-dangling\n    // References, indicating that readField(name, objOrRef) has a chance of\n    // working. Useful for filtering out dangling references from lists.\n    canRead = (objOrRef) => {\n        return isReference(objOrRef) ?\n            this.has(objOrRef.__ref)\n            : typeof objOrRef === \"object\";\n    };\n    // Bound function that converts an id or an object with a __typename and\n    // primary key fields to a Reference object. If called with a Reference object,\n    // that same Reference object is returned. Pass true for mergeIntoStore to persist\n    // an object into the store.\n    toReference = (objOrIdOrRef, mergeIntoStore) => {\n        if (typeof objOrIdOrRef === \"string\") {\n            return makeReference(objOrIdOrRef);\n        }\n        if (isReference(objOrIdOrRef)) {\n            return objOrIdOrRef;\n        }\n        const [id] = this.policies.identify(objOrIdOrRef);\n        if (id) {\n            const ref = makeReference(id);\n            if (mergeIntoStore) {\n                this.merge(id, objOrIdOrRef);\n            }\n            return ref;\n        }\n    };\n    get supportsResultCaching() {\n        return this.group.caching;\n    }\n}\n// A single CacheGroup represents a set of one or more EntityStore objects,\n// typically the Root store in a CacheGroup by itself, and all active Layer\n// stores in a group together. A single EntityStore object belongs to only\n// one CacheGroup, store.group. The CacheGroup is responsible for tracking\n// dependencies, so store.group is helpful for generating unique keys for\n// cached results that need to be invalidated when/if those dependencies\n// change. If we used the EntityStore objects themselves as cache keys (that\n// is, store rather than store.group), the cache would become unnecessarily\n// fragmented by all the different Layer objects. Instead, the CacheGroup\n// approach allows all optimistic Layer objects in the same linked list to\n// belong to one CacheGroup, with the non-optimistic Root object belonging\n// to another CacheGroup, allowing resultCaching dependencies to be tracked\n// separately for optimistic and non-optimistic entity data.\nclass CacheGroup {\n    caching;\n    parent;\n    d = null;\n    // Used by the EntityStore#makeCacheKey method to compute cache keys\n    // specific to this CacheGroup.\n    keyMaker;\n    constructor(caching, parent = null) {\n        this.caching = caching;\n        this.parent = parent;\n        this.resetCaching();\n    }\n    resetCaching() {\n        this.d = this.caching ? dep() : null;\n        this.keyMaker = new Trie();\n    }\n    depend(dataId, storeFieldName) {\n        if (this.d) {\n            this.d(makeDepKey(dataId, storeFieldName));\n            const fieldName = fieldNameFromStoreName(storeFieldName);\n            if (fieldName !== storeFieldName) {\n                // Fields with arguments that contribute extra identifying\n                // information to the fieldName (thus forming the storeFieldName)\n                // depend not only on the full storeFieldName but also on the\n                // short fieldName, so the field can be invalidated using either\n                // level of specificity.\n                this.d(makeDepKey(dataId, fieldName));\n            }\n            if (this.parent) {\n                this.parent.depend(dataId, storeFieldName);\n            }\n        }\n    }\n    dirty(dataId, storeFieldName) {\n        if (this.d) {\n            this.d.dirty(makeDepKey(dataId, storeFieldName), \n            // When storeFieldName === \"__exists\", that means the entity identified\n            // by dataId has either disappeared from the cache or was newly added,\n            // so the result caching system would do well to \"forget everything it\n            // knows\" about that object. To achieve that kind of invalidation, we\n            // not only dirty the associated result cache entry, but also remove it\n            // completely from the dependency graph. For the optimism implementation\n            // details, see https://github.com/benjamn/optimism/pull/195.\n            storeFieldName === \"__exists\" ? \"forget\" : \"setDirty\");\n        }\n    }\n}\nfunction makeDepKey(dataId, storeFieldName) {\n    // Since field names cannot have '#' characters in them, this method\n    // of joining the field name and the ID should be unambiguous, and much\n    // cheaper than JSON.stringify([dataId, fieldName]).\n    return storeFieldName + \"#\" + dataId;\n}\nexport function maybeDependOnExistenceOfEntity(store, entityId) {\n    if (supportsResultCaching(store)) {\n        // We use this pseudo-field __exists elsewhere in the EntityStore code to\n        // represent changes in the existence of the entity object identified by\n        // entityId. This dependency gets reliably dirtied whenever an object with\n        // this ID is deleted (or newly created) within this group, so any result\n        // cache entries (for example, StoreReader#executeSelectionSet results) that\n        // depend on __exists for this entityId will get dirtied as well, leading to\n        // the eventual recomputation (instead of reuse) of those result objects the\n        // next time someone reads them from the cache.\n        store.group.depend(entityId, \"__exists\");\n    }\n}\nclass Root extends EntityStore {\n    constructor({ policies, resultCaching = true, seed, }) {\n        super(policies, new CacheGroup(resultCaching));\n        if (seed)\n            this.replace(seed);\n    }\n    stump = new Stump(this);\n    addLayer(layerId, replay) {\n        // Adding an optimistic Layer on top of the Root actually adds the Layer\n        // on top of the Stump, so the Stump always comes between the Root and\n        // any Layer objects that we've added.\n        return this.stump.addLayer(layerId, replay);\n    }\n    removeLayer() {\n        // Never remove the root layer.\n        return this;\n    }\n    storageTrie = new Trie();\n    getStorage() {\n        return this.storageTrie.lookupArray(arguments);\n    }\n}\nEntityStore.Root = Root;\n// Not exported, since all Layer instances are created by the addLayer method\n// of the EntityStore.Root class.\nclass Layer extends EntityStore {\n    id;\n    parent;\n    replay;\n    group;\n    constructor(id, parent, replay, group) {\n        super(parent.policies, group);\n        this.id = id;\n        this.parent = parent;\n        this.replay = replay;\n        this.group = group;\n        replay(this);\n    }\n    addLayer(layerId, replay) {\n        return new Layer(layerId, this, replay, this.group);\n    }\n    removeLayer(layerId) {\n        // Remove all instances of the given id, not just the first one.\n        const parent = this.parent.removeLayer(layerId);\n        if (layerId === this.id) {\n            if (this.group.caching) {\n                // Dirty every ID we're removing. Technically we might be able to avoid\n                // dirtying fields that have values in higher layers, but we don't have\n                // easy access to higher layers here, and we're about to recreate those\n                // layers anyway (see parent.addLayer below).\n                Object.keys(this.data).forEach((dataId) => {\n                    const ownStoreObject = this.data[dataId];\n                    const parentStoreObject = parent[\"lookup\"](dataId);\n                    if (!parentStoreObject) {\n                        // The StoreObject identified by dataId was defined in this layer\n                        // but will be undefined in the parent layer, so we can delete the\n                        // whole entity using this.delete(dataId). Since we're about to\n                        // throw this layer away, the only goal of this deletion is to dirty\n                        // the removed fields.\n                        this.delete(dataId);\n                    }\n                    else if (!ownStoreObject) {\n                        // This layer had an entry for dataId but it was undefined, which\n                        // means the entity was deleted in this layer, and it's about to\n                        // become undeleted when we remove this layer, so we need to dirty\n                        // all fields that are about to be reexposed.\n                        this.group.dirty(dataId, \"__exists\");\n                        Object.keys(parentStoreObject).forEach((storeFieldName) => {\n                            this.group.dirty(dataId, storeFieldName);\n                        });\n                    }\n                    else if (ownStoreObject !== parentStoreObject) {\n                        // If ownStoreObject is not exactly the same as parentStoreObject,\n                        // dirty any fields whose values will change as a result of this\n                        // removal.\n                        Object.keys(ownStoreObject).forEach((storeFieldName) => {\n                            if (!equal(ownStoreObject[storeFieldName], parentStoreObject[storeFieldName])) {\n                                this.group.dirty(dataId, storeFieldName);\n                            }\n                        });\n                    }\n                });\n            }\n            return parent;\n        }\n        // No changes are necessary if the parent chain remains identical.\n        if (parent === this.parent)\n            return this;\n        // Recreate this layer on top of the new parent.\n        return parent.addLayer(this.id, this.replay);\n    }\n    toObject() {\n        return {\n            ...this.parent.toObject(),\n            ...this.data,\n        };\n    }\n    findChildRefIds(dataId) {\n        const fromParent = this.parent.findChildRefIds(dataId);\n        return hasOwn.call(this.data, dataId) ?\n            {\n                ...fromParent,\n                ...super.findChildRefIds(dataId),\n            }\n            : fromParent;\n    }\n    getStorage(...args) {\n        let p = this.parent;\n        while (p.parent)\n            p = p.parent;\n        return p.getStorage(...args);\n    }\n}\n// Represents a Layer permanently installed just above the Root, which allows\n// reading optimistically (and registering optimistic dependencies) even when\n// no optimistic layers are currently active. The stump.group CacheGroup object\n// is shared by any/all Layer objects added on top of the Stump.\nclass Stump extends Layer {\n    constructor(root) {\n        super(\"EntityStore.Stump\", root, () => { }, new CacheGroup(root.group.caching, root.group));\n    }\n    removeLayer() {\n        // Never remove the Stump layer.\n        return this;\n    }\n    merge(older, newer) {\n        // We never want to write any data into the Stump, so we forward any merge\n        // calls to the Root instead. Another option here would be to throw an\n        // exception, but the toReference(object, true) function can sometimes\n        // trigger Stump writes (which used to be Root writes, before the Stump\n        // concept was introduced).\n        return this.parent.merge(older, newer);\n    }\n}\nfunction storeObjectReconciler(existingObject, incomingObject, property) {\n    const existingValue = existingObject[property];\n    const incomingValue = incomingObject[property];\n    // Wherever there is a key collision, prefer the incoming value, unless\n    // it is deeply equal to the existing value. It's worth checking deep\n    // equality here (even though blindly returning incoming would be\n    // logically correct) because preserving the referential identity of\n    // existing data can prevent needless rereading and rerendering.\n    return equal(existingValue, incomingValue) ? existingValue : incomingValue;\n}\nexport function supportsResultCaching(store) {\n    // When result caching is disabled, store.depend will be null.\n    return !!(store && store.supportsResultCaching);\n}\n//# sourceMappingURL=entityStore.js.map\n"],"names":["hasOwn","isReference","invariant","DeepMerger","fieldNameFromStoreName","makeReference","maybeDeepFreeze","isNonNullObject","dep","Trie","equal"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/@apollo/client/cache/inmemory/helpers.cjs

@@ -0,0 +1,98 @@
+'use strict';
+
+var storeUtils = require('../../utilities/graphql/storeUtils.cjs');
+var compact = require('../../utilities/internal/compact.cjs');
+var isNonNullObject = require('../../utilities/internal/isNonNullObject.cjs');
+var isArray = require('../../utilities/internal/isArray.cjs');
+var isField = require('../../utilities/internal/isField.cjs');
+var shouldInclude = require('../../utilities/internal/shouldInclude.cjs');
+var resultKeyNameFromField = require('../../utilities/internal/resultKeyNameFromField.cjs');
+var createFragmentMap = require('../../utilities/internal/createFragmentMap.cjs');
+var getFragmentDefinitions = require('../../utilities/internal/getFragmentDefinitions.cjs');
+var DeepMerger = require('../../utilities/internal/DeepMerger.cjs');
+
+const { hasOwnProperty: hasOwn } = Object.prototype;
+function defaultDataIdFromObject({ __typename, id, _id }, context) {
+    if (typeof __typename === "string") {
+        if (context) {
+            context.keyObject =
+                id != null ? { id }
+                    : _id != null ? { _id }
+                        : void 0;
+        }
+        // If there is no object.id, fall back to object._id.
+        if (id == null && _id != null) {
+            id = _id;
+        }
+        if (id != null) {
+            return `${__typename}:${typeof id === "number" || typeof id === "string" ?
+                id
+                : JSON.stringify(id)}`;
+        }
+    }
+}
+const defaultConfig = {
+    dataIdFromObject: defaultDataIdFromObject,
+    resultCaching: true,
+};
+function normalizeConfig(config) {
+    return compact.compact(defaultConfig, config);
+}
+const TypeOrFieldNameRegExp = /^[_a-z][_0-9a-z]*/i;
+function fieldNameFromStoreName(storeFieldName) {
+    const match = storeFieldName.match(TypeOrFieldNameRegExp);
+    return match ? match[0] : storeFieldName;
+}
+function selectionSetMatchesResult(selectionSet, result, variables) {
+    if (isNonNullObject.isNonNullObject(result)) {
+        return isArray.isArray(result) ?
+            result.every((item) => selectionSetMatchesResult(selectionSet, item, variables))
+            : selectionSet.selections.every((field) => {
+                if (isField.isField(field) && shouldInclude.shouldInclude(field, variables)) {
+                    const key = resultKeyNameFromField.resultKeyNameFromField(field);
+                    return (hasOwn.call(result, key) &&
+                        (!field.selectionSet ||
+                            selectionSetMatchesResult(field.selectionSet, result[key], variables)));
+                }
+                // If the selection has been skipped with @skip(true) or
+                // @include(false), it should not count against the matching. If
+                // the selection is not a field, it must be a fragment (inline or
+                // named). We will determine if selectionSetMatchesResult for that
+                // fragment when we get to it, so for now we return true.
+                return true;
+            });
+    }
+    return false;
+}
+function storeValueIsStoreObject(value) {
+    return isNonNullObject.isNonNullObject(value) && !storeUtils.isReference(value) && !isArray.isArray(value);
+}
+function makeProcessedFieldsMerger() {
+    return new DeepMerger.DeepMerger();
+}
+function extractFragmentContext(document, fragments) {
+    // FragmentMap consisting only of fragments defined directly in document, not
+    // including other fragments registered in the FragmentRegistry.
+    const fragmentMap = createFragmentMap.createFragmentMap(getFragmentDefinitions.getFragmentDefinitions(document));
+    return {
+        fragmentMap,
+        lookupFragment(name) {
+            let def = fragmentMap[name];
+            if (!def && fragments) {
+                def = fragments.lookup(name);
+            }
+            return def || null;
+        },
+    };
+}
+
+exports.TypeOrFieldNameRegExp = TypeOrFieldNameRegExp;
+exports.defaultDataIdFromObject = defaultDataIdFromObject;
+exports.extractFragmentContext = extractFragmentContext;
+exports.fieldNameFromStoreName = fieldNameFromStoreName;
+exports.hasOwn = hasOwn;
+exports.makeProcessedFieldsMerger = makeProcessedFieldsMerger;
+exports.normalizeConfig = normalizeConfig;
+exports.selectionSetMatchesResult = selectionSetMatchesResult;
+exports.storeValueIsStoreObject = storeValueIsStoreObject;
+//# sourceMappingURL=helpers.cjs.map

package/dist/cjs/node_modules/@apollo/client/cache/inmemory/helpers.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.cjs","sources":["../../../../../../../node_modules/@apollo/client/cache/inmemory/helpers.js"],"sourcesContent":["import { isReference } from \"@apollo/client/utilities\";\nimport { compact, createFragmentMap, DeepMerger, getFragmentDefinitions, isArray, isField, isNonNullObject, resultKeyNameFromField, shouldInclude, } from \"@apollo/client/utilities/internal\";\nexport const { hasOwnProperty: hasOwn } = Object.prototype;\nexport function defaultDataIdFromObject({ __typename, id, _id }, context) {\n    if (typeof __typename === \"string\") {\n        if (context) {\n            context.keyObject =\n                id != null ? { id }\n                    : _id != null ? { _id }\n                        : void 0;\n        }\n        // If there is no object.id, fall back to object._id.\n        if (id == null && _id != null) {\n            id = _id;\n        }\n        if (id != null) {\n            return `${__typename}:${typeof id === \"number\" || typeof id === \"string\" ?\n                id\n                : JSON.stringify(id)}`;\n        }\n    }\n}\nconst defaultConfig = {\n    dataIdFromObject: defaultDataIdFromObject,\n    resultCaching: true,\n};\nexport function normalizeConfig(config) {\n    return compact(defaultConfig, config);\n}\nexport function getTypenameFromStoreObject(store, objectOrReference) {\n    return isReference(objectOrReference) ?\n        store.get(objectOrReference.__ref, \"__typename\")\n        : objectOrReference && objectOrReference.__typename;\n}\nexport const TypeOrFieldNameRegExp = /^[_a-z][_0-9a-z]*/i;\nexport function fieldNameFromStoreName(storeFieldName) {\n    const match = storeFieldName.match(TypeOrFieldNameRegExp);\n    return match ? match[0] : storeFieldName;\n}\nexport function selectionSetMatchesResult(selectionSet, result, variables) {\n    if (isNonNullObject(result)) {\n        return isArray(result) ?\n            result.every((item) => selectionSetMatchesResult(selectionSet, item, variables))\n            : selectionSet.selections.every((field) => {\n                if (isField(field) && shouldInclude(field, variables)) {\n                    const key = resultKeyNameFromField(field);\n                    return (hasOwn.call(result, key) &&\n                        (!field.selectionSet ||\n                            selectionSetMatchesResult(field.selectionSet, result[key], variables)));\n                }\n                // If the selection has been skipped with @skip(true) or\n                // @include(false), it should not count against the matching. If\n                // the selection is not a field, it must be a fragment (inline or\n                // named). We will determine if selectionSetMatchesResult for that\n                // fragment when we get to it, so for now we return true.\n                return true;\n            });\n    }\n    return false;\n}\nexport function storeValueIsStoreObject(value) {\n    return isNonNullObject(value) && !isReference(value) && !isArray(value);\n}\nexport function makeProcessedFieldsMerger() {\n    return new DeepMerger();\n}\nexport function extractFragmentContext(document, fragments) {\n    // FragmentMap consisting only of fragments defined directly in document, not\n    // including other fragments registered in the FragmentRegistry.\n    const fragmentMap = createFragmentMap(getFragmentDefinitions(document));\n    return {\n        fragmentMap,\n        lookupFragment(name) {\n            let def = fragmentMap[name];\n            if (!def && fragments) {\n                def = fragments.lookup(name);\n            }\n            return def || null;\n        },\n    };\n}\n//# sourceMappingURL=helpers.js.map"],"names":["compact","isNonNullObject","isArray","isField","shouldInclude","resultKeyNameFromField","isReference","DeepMerger","createFragmentMap","getFragmentDefinitions"],"mappings":"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","x_google_ignoreList":[0]}