@isograph/react 0.0.0-main-3de26263 → 0.0.0-main-709dc2bb

package/dist/core/optimisticProxy.js

@@ -1,381 +1,273 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getOrInsertRecord = getOrInsertRecord;
-exports.getStoreRecordProxy = getStoreRecordProxy;
-exports.getMutableStoreRecordProxy = getMutableStoreRecordProxy;
-exports.addNetworkResponseStoreLayer = addNetworkResponseStoreLayer;
-exports.addStartUpdateStoreLayer = addStartUpdateStoreLayer;
-exports.addOptimisticUpdaterStoreLayer = addOptimisticUpdaterStoreLayer;
-exports.addOptimisticNetworkResponseStoreLayer = addOptimisticNetworkResponseStoreLayer;
-exports.revertOptimisticStoreLayerAndMaybeReplace = revertOptimisticStoreLayerAndMaybeReplace;
-const cache_1 = require("./cache");
-const subscribe_1 = require("./subscribe");
+const require_subscribe = require('./subscribe.js');
+const require_cache = require('./cache.js');
+
+//#region src/core/optimisticProxy.ts
 function getOrInsertRecord(dataLayer, link) {
-    var _a, _b;
-    var _c, _d;
-    const recordsById = ((_a = dataLayer[_c = link.__typename]) !== null && _a !== void 0 ? _a : (dataLayer[_c] = {}));
-    return ((_b = recordsById[_d = link.__link]) !== null && _b !== void 0 ? _b : (recordsById[_d] = {}));
+	const recordsById = dataLayer[link.__typename] ??= {};
+	return recordsById[link.__link] ??= {};
 }
 /**
- * Given the child-most store layer (i.e. environment.store) and a link (identifying a
- * store record), create a proxy object that attempts to read through each successive
- * store layer until a value (i.e. field name) is found. If found, return that value.
- */
+* Given the child-most store layer (i.e. environment.store) and a link (identifying a
+* store record), create a proxy object that attempts to read through each successive
+* store layer until a value (i.e. field name) is found. If found, return that value.
+*/
 function getStoreRecordProxy(storeLayer, link) {
-    var _a;
-    let startNode = storeLayer;
-    while (startNode != null) {
-        const storeRecord = (_a = startNode.data[link.__typename]) === null || _a === void 0 ? void 0 : _a[link.__link];
-        if (storeRecord === undefined) {
-            startNode = startNode.parentStoreLayer;
-            continue;
-        }
-        if (storeRecord == null) {
-            return null;
-        }
-        return getMutableStoreRecordProxy(startNode, link);
-    }
-    return undefined;
+	let startNode = storeLayer;
+	while (startNode != null) {
+		const storeRecord = startNode.data[link.__typename]?.[link.__link];
+		if (storeRecord === void 0) {
+			startNode = startNode.parentStoreLayer;
+			continue;
+		}
+		if (storeRecord == null) return null;
+		return getMutableStoreRecordProxy(startNode, link);
+	}
 }
 function getMutableStoreRecordProxy(childMostStoreLayer, link) {
-    return new Proxy({}, {
-        get(_, propertyName) {
-            var _a;
-            let currentStoreLayer = childMostStoreLayer;
-            while (currentStoreLayer != null) {
-                const storeRecord = (_a = currentStoreLayer.data[link.__typename]) === null || _a === void 0 ? void 0 : _a[link.__link];
-                if (storeRecord !== undefined) {
-                    if (storeRecord == null) {
-                        return undefined;
-                    }
-                    const value = Reflect.get(storeRecord, propertyName);
-                    if (value !== undefined) {
-                        return value;
-                    }
-                }
-                currentStoreLayer = currentStoreLayer.parentStoreLayer;
-            }
-        },
-        has(_, propertyName) {
-            var _a;
-            let currentStoreLayer = childMostStoreLayer;
-            while (currentStoreLayer != null) {
-                const storeRecord = (_a = currentStoreLayer.data[link.__typename]) === null || _a === void 0 ? void 0 : _a[link.__link];
-                if (storeRecord !== undefined) {
-                    if (storeRecord == null) {
-                        return false;
-                    }
-                    const value = Reflect.has(storeRecord, propertyName);
-                    if (value) {
-                        return true;
-                    }
-                }
-                currentStoreLayer = currentStoreLayer.parentStoreLayer;
-            }
-            return false;
-        },
-        set(_, p, newValue) {
-            return Reflect.set(getOrInsertRecord(childMostStoreLayer.data, link), p, newValue);
-        },
-    });
+	return new Proxy({}, {
+		get(_, propertyName) {
+			let currentStoreLayer = childMostStoreLayer;
+			while (currentStoreLayer != null) {
+				const storeRecord = currentStoreLayer.data[link.__typename]?.[link.__link];
+				if (storeRecord !== void 0) {
+					if (storeRecord == null) return;
+					const value = Reflect.get(storeRecord, propertyName);
+					if (value !== void 0) return value;
+				}
+				currentStoreLayer = currentStoreLayer.parentStoreLayer;
+			}
+		},
+		has(_, propertyName) {
+			let currentStoreLayer = childMostStoreLayer;
+			while (currentStoreLayer != null) {
+				const storeRecord = currentStoreLayer.data[link.__typename]?.[link.__link];
+				if (storeRecord !== void 0) {
+					if (storeRecord == null) return false;
+					if (Reflect.has(storeRecord, propertyName)) return true;
+				}
+				currentStoreLayer = currentStoreLayer.parentStoreLayer;
+			}
+			return false;
+		},
+		set(_, p, newValue) {
+			return Reflect.set(getOrInsertRecord(childMostStoreLayer.data, link), p, newValue);
+		}
+	});
 }
 function addNetworkResponseStoreLayer(parent) {
-    switch (parent.kind) {
-        case 'NetworkResponseStoreLayer':
-        case 'BaseStoreLayer': {
-            return parent;
-        }
-        case 'StartUpdateStoreLayer':
-        case 'OptimisticNetworkResponseStoreLayer':
-        case 'OptimisticUpdaterStoreLayer': {
-            const node = {
-                kind: 'NetworkResponseStoreLayer',
-                parentStoreLayer: parent,
-                childStoreLayer: null,
-                data: {},
-            };
-            parent.childStoreLayer = node;
-            return node;
-        }
-    }
+	switch (parent.kind) {
+		case "NetworkResponseStoreLayer":
+		case "BaseStoreLayer": return parent;
+		case "StartUpdateStoreLayer":
+		case "OptimisticNetworkResponseStoreLayer":
+		case "OptimisticUpdaterStoreLayer": {
+			const node = {
+				kind: "NetworkResponseStoreLayer",
+				parentStoreLayer: parent,
+				childStoreLayer: null,
+				data: {}
+			};
+			parent.childStoreLayer = node;
+			return node;
+		}
+	}
 }
 function mergeDataLayer(target, source) {
-    var _a, _b;
-    for (const [typeName, sourceById] of Object.entries(source)) {
-        if (sourceById == null) {
-            target[typeName] = sourceById;
-            continue;
-        }
-        const targetRecordById = ((_a = target[typeName]) !== null && _a !== void 0 ? _a : (target[typeName] = {}));
-        for (const [id, sourceRecord] of Object.entries(sourceById)) {
-            if (sourceRecord == null) {
-                targetRecordById[id] = null;
-                continue;
-            }
-            const targetRecord = ((_b = targetRecordById[id]) !== null && _b !== void 0 ? _b : (targetRecordById[id] = {}));
-            Object.assign(targetRecord, sourceRecord);
-        }
-    }
+	for (const [typeName, sourceById] of Object.entries(source)) {
+		if (sourceById == null) {
+			target[typeName] = sourceById;
+			continue;
+		}
+		const targetRecordById = target[typeName] ??= {};
+		for (const [id, sourceRecord] of Object.entries(sourceById)) {
+			if (sourceRecord == null) {
+				targetRecordById[id] = null;
+				continue;
+			}
+			const targetRecord = targetRecordById[id] ??= {};
+			Object.assign(targetRecord, sourceRecord);
+		}
+	}
 }
 function addStartUpdateStoreLayer(parent, startUpdate) {
-    switch (parent.kind) {
-        case 'BaseStoreLayer': {
-            startUpdate(parent);
-            return parent;
-        }
-        case 'StartUpdateStoreLayer': {
-            const node = parent;
-            const prevStartUpdate = node.startUpdate;
-            node.startUpdate = () => {
-                prevStartUpdate(node);
-                startUpdate(node);
-            };
-            startUpdate(node);
-            return node;
-        }
-        case 'NetworkResponseStoreLayer':
-        case 'OptimisticNetworkResponseStoreLayer':
-        case 'OptimisticUpdaterStoreLayer': {
-            const node = {
-                kind: 'StartUpdateStoreLayer',
-                parentStoreLayer: parent,
-                childStoreLayer: null,
-                data: {},
-                startUpdate: startUpdate,
-            };
-            parent.childStoreLayer = node;
-            startUpdate(node);
-            return node;
-        }
-    }
-}
-function addOptimisticUpdaterStoreLayer(parent, startUpdate) {
-    switch (parent.kind) {
-        case 'BaseStoreLayer':
-        case 'StartUpdateStoreLayer':
-        case 'NetworkResponseStoreLayer':
-        case 'OptimisticNetworkResponseStoreLayer':
-        case 'OptimisticUpdaterStoreLayer': {
-            const node = {
-                kind: 'OptimisticUpdaterStoreLayer',
-                parentStoreLayer: parent,
-                childStoreLayer: null,
-                data: {},
-                startUpdate: startUpdate,
-            };
-            startUpdate(node);
-            parent.childStoreLayer = node;
-            return node;
-        }
-    }
+	switch (parent.kind) {
+		case "BaseStoreLayer":
+			startUpdate(parent);
+			return parent;
+		case "StartUpdateStoreLayer": {
+			const node = parent;
+			const prevStartUpdate = node.startUpdate;
+			node.startUpdate = () => {
+				prevStartUpdate(node);
+				startUpdate(node);
+			};
+			startUpdate(node);
+			return node;
+		}
+		case "NetworkResponseStoreLayer":
+		case "OptimisticNetworkResponseStoreLayer":
+		case "OptimisticUpdaterStoreLayer": {
+			const node = {
+				kind: "StartUpdateStoreLayer",
+				parentStoreLayer: parent,
+				childStoreLayer: null,
+				data: {},
+				startUpdate
+			};
+			parent.childStoreLayer = node;
+			startUpdate(node);
+			return node;
+		}
+	}
 }
 function addOptimisticNetworkResponseStoreLayer(parent) {
-    switch (parent.kind) {
-        case 'BaseStoreLayer':
-        case 'StartUpdateStoreLayer':
-        case 'NetworkResponseStoreLayer':
-        case 'OptimisticNetworkResponseStoreLayer':
-        case 'OptimisticUpdaterStoreLayer': {
-            const node = {
-                kind: 'OptimisticNetworkResponseStoreLayer',
-                parentStoreLayer: parent,
-                childStoreLayer: null,
-                data: {},
-            };
-            parent.childStoreLayer = node;
-            return node;
-        }
-    }
+	switch (parent.kind) {
+		case "BaseStoreLayer":
+		case "StartUpdateStoreLayer":
+		case "NetworkResponseStoreLayer":
+		case "OptimisticNetworkResponseStoreLayer":
+		case "OptimisticUpdaterStoreLayer": {
+			const node = {
+				kind: "OptimisticNetworkResponseStoreLayer",
+				parentStoreLayer: parent,
+				childStoreLayer: null,
+				data: {}
+			};
+			parent.childStoreLayer = node;
+			return node;
+		}
+	}
 }
 /**
- * Merge storeLayerToMerge, and its children, into baseStoreLayer.
- * We can merge until we reach a revertible layer (i.e. an optimistic layer).
- * All other layers cannot be reverted, so for housekeeping + perf, we merge
- * them into a single layer.
- *
- * Note that BaseStoreLayer.childStoreLayer has type OptimisticStoreLayer | null.
- * So, the state of the stack is never e.g. base <- network response. Instead,
- * we have a base + a child that we would like to attach to the base. So, we merge
- * (flatten) until we reach an optimistic layer or null, at which point, we can
- * set baseStoreLayer.childStoreLayer = storeLayerToMerge (via setChildOfNode).
- */
+* Merge storeLayerToMerge, and its children, into baseStoreLayer.
+* We can merge until we reach a revertible layer (i.e. an optimistic layer).
+* All other layers cannot be reverted, so for housekeeping + perf, we merge
+* them into a single layer.
+*
+* Note that BaseStoreLayer.childStoreLayer has type OptimisticStoreLayer | null.
+* So, the state of the stack is never e.g. base <- network response. Instead,
+* we have a base + a child that we would like to attach to the base. So, we merge
+* (flatten) until we reach an optimistic layer or null, at which point, we can
+* set baseStoreLayer.childStoreLayer = storeLayerToMerge (via setChildOfNode).
+*/
 function mergeLayersWithDataIntoBaseLayer(environment, storeLayerToMerge, baseStoreLayer) {
-    while (storeLayerToMerge != null &&
-        storeLayerToMerge.kind !== 'OptimisticUpdaterStoreLayer') {
-        mergeDataLayer(baseStoreLayer.data, storeLayerToMerge.data);
-        storeLayerToMerge = storeLayerToMerge.childStoreLayer;
-    }
-    setChildOfNode(environment, baseStoreLayer, storeLayerToMerge);
+	while (storeLayerToMerge != null && storeLayerToMerge.kind !== "OptimisticUpdaterStoreLayer") {
+		mergeDataLayer(baseStoreLayer.data, storeLayerToMerge.data);
+		storeLayerToMerge = storeLayerToMerge.childStoreLayer;
+	}
+	setChildOfNode(environment, baseStoreLayer, storeLayerToMerge);
 }
 /**
- * Now that we have replaced the optimistic layer with a network response layer, we need
- * to
- * - re-execute startUpdate and optimistic nodes, in light of the replaced data, and
- * - create two objects containing the old merged data (from the optimistic update layer
- *   onward) and the new merged data (from the network response layer onward).
- * - we will compare the new and old merged data in order to determine the changed records
- *   and trigger subscriptions.
- *
- * Here, "merged data" means all of the records + fields that were modified, starting at
- * storeLayer, e.g. in BaseLayer <- OptimisticLayer <- StartUpdateLayer, if we
- * are replacing Optimistic, then oldData will contain the records + fields modified by
- * OptimisticLayer + StartUpdateLayer.
- */
-function reexecuteUpdatesAndMergeData(storeLayer, 
-// reflects the (now reverted) optimistic layer
-oldMergedData, 
-// reflects whatever replaced the optimistic layer
-newMergedData) {
-    while (storeLayer != null) {
-        mergeDataLayer(oldMergedData, storeLayer.data);
-        switch (storeLayer.kind) {
-            case 'OptimisticNetworkResponseStoreLayer':
-            case 'NetworkResponseStoreLayer':
-                break;
-            case 'StartUpdateStoreLayer': {
-                storeLayer.data = {};
-                storeLayer.startUpdate(storeLayer);
-                break;
-            }
-            case 'OptimisticUpdaterStoreLayer': {
-                storeLayer.data = {};
-                storeLayer.startUpdate(storeLayer);
-                break;
-            }
-        }
-        mergeDataLayer(newMergedData, storeLayer.data);
-        storeLayer = storeLayer.childStoreLayer;
-    }
+* Now that we have replaced the optimistic layer with a network response layer, we need
+* to
+* - re-execute startUpdate and optimistic nodes, in light of the replaced data, and
+* - create two objects containing the old merged data (from the optimistic update layer
+*   onward) and the new merged data (from the network response layer onward).
+* - we will compare the new and old merged data in order to determine the changed records
+*   and trigger subscriptions.
+*
+* Here, "merged data" means all of the records + fields that were modified, starting at
+* storeLayer, e.g. in BaseLayer <- OptimisticLayer <- StartUpdateLayer, if we
+* are replacing Optimistic, then oldData will contain the records + fields modified by
+* OptimisticLayer + StartUpdateLayer.
+*/
+function reexecuteUpdatesAndMergeData(storeLayer, oldMergedData, newMergedData) {
+	while (storeLayer != null) {
+		mergeDataLayer(oldMergedData, storeLayer.data);
+		switch (storeLayer.kind) {
+			case "OptimisticNetworkResponseStoreLayer":
+			case "NetworkResponseStoreLayer": break;
+			case "StartUpdateStoreLayer":
+				storeLayer.data = {};
+				storeLayer.startUpdate(storeLayer);
+				break;
+			case "OptimisticUpdaterStoreLayer":
+				storeLayer.data = {};
+				storeLayer.startUpdate(storeLayer);
+				break;
+		}
+		mergeDataLayer(newMergedData, storeLayer.data);
+		storeLayer = storeLayer.childStoreLayer;
+	}
 }
 /**
- * Set storeLayerToModify's child to a given layer. This may be null!
- * If it is null, set the environment.store to storeLayerToModify.
- * If it is not null, then the existing environment.store value remains
- * valid.
- */
+* Set storeLayerToModify's child to a given layer. This may be null!
+* If it is null, set the environment.store to storeLayerToModify.
+* If it is not null, then the existing environment.store value remains
+* valid.
+*/
 function setChildOfNode(environment, storeLayerToModify, newChildStoreLayer) {
-    storeLayerToModify.childStoreLayer = newChildStoreLayer;
-    if (newChildStoreLayer != null) {
-        newChildStoreLayer.parentStoreLayer = storeLayerToModify;
-    }
-    else {
-        environment.store = storeLayerToModify;
-    }
+	storeLayerToModify.childStoreLayer = newChildStoreLayer;
+	if (newChildStoreLayer != null) newChildStoreLayer.parentStoreLayer = storeLayerToModify;
+	else environment.store = storeLayerToModify;
 }
 /**
- * Remove an optimistic store layer from the stack, potentially replacing it
- * with a network response.
- *
- * After we do this, we must re-execute all child startUpdate and optimistic
- * layers (since their data may have changed.) We also keep track of changed
- * records, in order to call affected subscriptions.
- */
+* Remove an optimistic store layer from the stack, potentially replacing it
+* with a network response.
+*
+* After we do this, we must re-execute all child startUpdate and optimistic
+* layers (since their data may have changed.) We also keep track of changed
+* records, in order to call affected subscriptions.
+*/
 function revertOptimisticStoreLayerAndMaybeReplace(environment, optimisticNode, normalizeData) {
-    var _a;
-    // We cannot just replace the optimistic node with the network response node,
-    // because (e.g.) the types allow Base <- Opt, but not Base <- NetworkResponse.
-    // We also may be removing the optimistic layer without replacing it with
-    // anything, which would also be disallowed if the original stack was
-    // Base <- Opt <- NetworkResponse.
-    //
-    // Thus, instead, we will (1) replace the optimistic node's data with an empty object
-    // and attach the network response as a child.
-    const oldMergedData = optimisticNode.data;
-    optimisticNode.data = {};
-    let newMergedData = {};
-    let childNode = optimisticNode.childStoreLayer;
-    if (normalizeData != null) {
-        const networkResponseStoreLayer = {
-            kind: 'NetworkResponseStoreLayer',
-            data: {},
-            parentStoreLayer: optimisticNode,
-            childStoreLayer: null,
-        };
-        normalizeData(networkResponseStoreLayer);
-        if ((childNode === null || childNode === void 0 ? void 0 : childNode.kind) === 'NetworkResponseStoreLayer') {
-            // (2) if the optimistic layer's child was a network response, and we are
-            // replacing it with a network response, we must merge the replacement
-            // and the child.
-            mergeDataLayer(networkResponseStoreLayer.data, childNode.data);
-            mergeDataLayer(oldMergedData, childNode.data);
-            childNode = childNode.childStoreLayer;
-        }
-        newMergedData = structuredClone(networkResponseStoreLayer.data);
-        setChildOfNode(environment, networkResponseStoreLayer, childNode);
-        optimisticNode.childStoreLayer = networkResponseStoreLayer;
-    }
-    // (3) Re-execute all updates, accumulating all changed values into newMergedData.
-    // Since we have already written the network response into newMergedData, we
-    // can proceed from the child of the (potentially merged) network response layer.
-    //
-    // Note that it is important that reexecuteUpdatesAndMergeData is called here!
-    // That is because we created newMergedData from the network response layer's data,
-    // and later, we may merge that network response into the parent layer (if it is
-    // a base layer). That merged layer will contain many extraneous records (unless the
-    // base layer is empty).
-    //
-    // This would cause us to re-execute subscriptions unnecessarily, as these records
-    // do not represent changes between the optimistic and network response layers.
-    reexecuteUpdatesAndMergeData(childNode, oldMergedData, newMergedData);
-    // (4) Now, we can finally remove the optimistic layer, i.e. do
-    // optimistic.parent.child = optimistic.child.
-    // But the types don't line up, so we handle the cases differently, based on the
-    // parent layer type.
-    if (optimisticNode.parentStoreLayer.kind === 'BaseStoreLayer') {
-        // (4a) If the optimistic parent is the base layer, then we have a problem: base.child
-        // must be an optimistic layer or null. So, we merge the optimistic children into the
-        // base layer until we reach an optimistic layer.
-        mergeLayersWithDataIntoBaseLayer(environment, optimisticNode.childStoreLayer, optimisticNode.parentStoreLayer);
-    }
-    else if (optimisticNode.parentStoreLayer.kind === 'NetworkResponseStoreLayer' &&
-        ((_a = optimisticNode.childStoreLayer) === null || _a === void 0 ? void 0 : _a.kind) === 'NetworkResponseStoreLayer') {
-        // (4b) if the parent is a network response layer, simply merge those. (We do not
-        // attempt to merge other layers, e.g. startUpdate layers, because there is some
-        // optimistic layer between this layer and the base, and the startUpdate will need
-        // to be recalculated if the optimistic layer is reverted.)
-        mergeDataLayer(optimisticNode.parentStoreLayer.data, optimisticNode.childStoreLayer.data);
-        setChildOfNode(environment, optimisticNode.parentStoreLayer, optimisticNode.childStoreLayer.childStoreLayer);
-    }
-    else {
-        // (4c) Otherwise, the parent is an optimistic or start update layer, and we can
-        // set optimistic.parent.child = optimistic.child.
-        setChildOfNode(environment, optimisticNode.parentStoreLayer, optimisticNode.childStoreLayer);
-    }
-    // (5) finally, compare the oldMergedData and newMergedData objects, in order to extract
-    // the modified IDs, and re-execute subscriptions.
-    let encounteredIds = new Map();
-    compareData(oldMergedData, newMergedData, encounteredIds);
-    (0, subscribe_1.callSubscriptions)(environment, encounteredIds);
+	const oldMergedData = optimisticNode.data;
+	optimisticNode.data = {};
+	let newMergedData = {};
+	let childNode = optimisticNode.childStoreLayer;
+	if (normalizeData != null) {
+		const networkResponseStoreLayer = {
+			kind: "NetworkResponseStoreLayer",
+			data: {},
+			parentStoreLayer: optimisticNode,
+			childStoreLayer: null
+		};
+		normalizeData(networkResponseStoreLayer);
+		if (childNode?.kind === "NetworkResponseStoreLayer") {
+			mergeDataLayer(networkResponseStoreLayer.data, childNode.data);
+			mergeDataLayer(oldMergedData, childNode.data);
+			childNode = childNode.childStoreLayer;
+		}
+		newMergedData = structuredClone(networkResponseStoreLayer.data);
+		setChildOfNode(environment, networkResponseStoreLayer, childNode);
+		optimisticNode.childStoreLayer = networkResponseStoreLayer;
+	}
+	reexecuteUpdatesAndMergeData(childNode, oldMergedData, newMergedData);
+	if (optimisticNode.parentStoreLayer.kind === "BaseStoreLayer") mergeLayersWithDataIntoBaseLayer(environment, optimisticNode.childStoreLayer, optimisticNode.parentStoreLayer);
+	else if (optimisticNode.parentStoreLayer.kind === "NetworkResponseStoreLayer" && optimisticNode.childStoreLayer?.kind === "NetworkResponseStoreLayer") {
+		mergeDataLayer(optimisticNode.parentStoreLayer.data, optimisticNode.childStoreLayer.data);
+		setChildOfNode(environment, optimisticNode.parentStoreLayer, optimisticNode.childStoreLayer.childStoreLayer);
+	} else setChildOfNode(environment, optimisticNode.parentStoreLayer, optimisticNode.childStoreLayer);
+	let encounteredIds = /* @__PURE__ */ new Map();
+	compareData(oldMergedData, newMergedData, encounteredIds);
+	require_subscribe.callSubscriptions(environment, encounteredIds);
 }
 function compareData(oldData, newData, encounteredIds) {
-    var _a;
-    const oldDataTypeNames = new Set(Object.keys(oldData));
-    const newDataTypeNames = new Set(Object.keys(newData));
-    for (const oldTypeName of oldDataTypeNames.difference(newDataTypeNames)) {
-        const set = (0, cache_1.insertEmptySetIfMissing)(encounteredIds, oldTypeName);
-        for (const id in oldData[oldTypeName]) {
-            set.add(id);
-        }
-    }
-    for (const [typeName, newRecords] of Object.entries(newData)) {
-        if (newRecords == null) {
-            continue;
-        }
-        const oldRecords = oldData[typeName];
-        outer: for (const [id, newRecord] of Object.entries(newRecords)) {
-            if (newRecord == null) {
-                continue;
-            }
-            const oldRecord = oldRecords === null || oldRecords === void 0 ? void 0 : oldRecords[id];
-            for (const [recordKey, newRecordValue] of Object.entries(newRecord)) {
-                // TODO: compare links, compare arrays
-                if (newRecordValue !== (oldRecord === null || oldRecord === void 0 ? void 0 : oldRecord[recordKey])) {
-                    const set = (0, cache_1.insertEmptySetIfMissing)(encounteredIds, typeName);
-                    set.add(id);
-                    continue outer;
-                }
-            }
-            (_a = encounteredIds.get(typeName)) === null || _a === void 0 ? void 0 : _a.delete(id);
-        }
-    }
+	const oldDataTypeNames = new Set(Object.keys(oldData));
+	const newDataTypeNames = new Set(Object.keys(newData));
+	for (const oldTypeName of oldDataTypeNames.difference(newDataTypeNames)) {
+		const set = require_cache.insertEmptySetIfMissing(encounteredIds, oldTypeName);
+		for (const id in oldData[oldTypeName]) set.add(id);
+	}
+	for (const [typeName, newRecords] of Object.entries(newData)) {
+		if (newRecords == null) continue;
+		const oldRecords = oldData[typeName];
+		outer: for (const [id, newRecord] of Object.entries(newRecords)) {
+			if (newRecord == null) continue;
+			const oldRecord = oldRecords?.[id];
+			for (const [recordKey, newRecordValue] of Object.entries(newRecord)) if (newRecordValue !== oldRecord?.[recordKey]) {
+				require_cache.insertEmptySetIfMissing(encounteredIds, typeName).add(id);
+				continue outer;
+			}
+			encounteredIds.get(typeName)?.delete(id);
+		}
+	}
 }
+
+//#endregion
+exports.addNetworkResponseStoreLayer = addNetworkResponseStoreLayer;
+exports.addOptimisticNetworkResponseStoreLayer = addOptimisticNetworkResponseStoreLayer;
+exports.addStartUpdateStoreLayer = addStartUpdateStoreLayer;
+exports.getMutableStoreRecordProxy = getMutableStoreRecordProxy;
+exports.getOrInsertRecord = getOrInsertRecord;
+exports.getStoreRecordProxy = getStoreRecordProxy;
+exports.revertOptimisticStoreLayerAndMaybeReplace = revertOptimisticStoreLayerAndMaybeReplace;