@warp-drive-mirror/json-api 5.10.0-alpha.7 → 5.10.0-alpha.8

package/dist/unpkg/prod-deprecated/index.js

@@ -1035,20 +1035,89 @@ function getDefaultValue(schema, identifier, store) {
 		if (transform?.defaultValue) return transform.defaultValue(options || null, identifier);
 	}
 }
-function calculateChangedKeys(cached, updates, fields) {
-	const changedKeys = /* @__PURE__ */ new Set();
-	const keys = Object.keys(updates);
-	const length = keys.length;
-	const localAttrs = cached.localAttrs;
-	const original = Object.assign(Object.create(null), cached.remoteAttrs, cached.inflightAttrs);
-	for (let i = 0; i < length; i++) {
+/**
+* Narrow `subset` to the members that survived {@link patchLocalAttributes}' pruning. Only called
+* when that pruning actually removed something, so the allocation is skipped on the common path
+* where a resource has no local edits at all.
+*/
+function retainSurviving(subset, survivors) {
+	if (!subset?.size) return subset;
+	const result = /* @__PURE__ */ new Set();
+	for (const key of subset) if (survivors.has(key)) result.add(key);
+	return result.size ? result : void 0;
+}
+/**
+* Which projection each changed key moved, so the caller can notify on the matching channel:
+* `localOnly` and `remoteOnly` on theirs, `both` unscoped. `remoteChanged` is the union
+* {@link patchLocalAttributes} reconciles against.
+*
+* `undefined` rather than empty Sets: this runs on every `upsert`, and a resource where nothing
+* moved should cost no allocation.
+*/
+const NO_PROJECTION_CHANGES = Object.freeze({
+	localOnly: void 0,
+	remoteOnly: void 0,
+	both: void 0,
+	remoteChanged: void 0
+});
+/**
+* The keys a merge could move: everything the payload carries, plus anything being promoted that
+* the payload did not mention. `null` when there is nothing to examine.
+*
+* `upsert` promotes nothing, so it gets the `Object.keys` array back unchanged. Only a commit
+* carrying both a payload and promoted attrs pays for a copy, and that is once per save rather
+* than once per resource in a document.
+*/
+function candidateKeys(updates, promoted) {
+	const updateKeys = updates ? Object.keys(updates) : null;
+	const promotedKeys = promoted ? Object.keys(promoted) : null;
+	if (!promotedKeys?.length) return updateKeys?.length ? updateKeys : null;
+	if (!updateKeys?.length) return promotedKeys;
+	const keys = updateKeys.slice();
+	for (let i = 0; i < promotedKeys.length; i++) if (!(promotedKeys[i] in updates)) keys.push(promotedKeys[i]);
+	return keys;
+}
+/**
+* Partition the keys an incoming payload touches by which projection each one moves.
+*
+* Takes the values rather than the `CachedResource` so it cannot observe the merge it is
+* describing: `prevRemote` is the remote state as it stands *before* `promoted` and `updates` are
+* applied, and the two callers merge different things. Reading them off `cached` would make the
+* result depend on whether the caller had already mutated it.
+*/
+function calculateChangedKeys(prevRemote, localAttrs, updates, promoted, fields) {
+	const keys = candidateKeys(updates, promoted);
+	if (keys === null) return NO_PROJECTION_CHANGES;
+	let localOnly;
+	let remoteOnly;
+	let both;
+	let remoteChanged;
+	for (let i = 0; i < keys.length; i++) {
 		const key = keys[i];
-		if (!fields.has(key)) continue;
-		const value = updates[key];
-		if (localAttrs && localAttrs[key] !== void 0) continue;
-		if (original[key] !== value) changedKeys.add(key);
+		const field = fields.get(key);
+		if (!field || isRelationship(field)) continue;
+		const isPromoted = promoted !== null && key in promoted;
+		const isUpdated = updates !== void 0 && key in updates;
+		const wasRemote = prevRemote ? prevRemote[key] : void 0;
+		const nowRemote = isUpdated ? updates[key] : isPromoted ? promoted[key] : wasRemote;
+		const localEdit = localAttrs ? localAttrs[key] : void 0;
+		const isEdited = localEdit !== void 0;
+		const wasLocal = isEdited ? localEdit : isPromoted ? promoted[key] : wasRemote;
+		const nowLocal = isEdited ? localEdit : nowRemote;
+		const remoteMoved = wasRemote !== nowRemote;
+		const localMoved = wasLocal !== nowLocal;
+		if (remoteMoved) {
+			(remoteChanged ??= /* @__PURE__ */ new Set()).add(key);
+			if (localMoved) (both ??= /* @__PURE__ */ new Set()).add(key);
+			else (remoteOnly ??= /* @__PURE__ */ new Set()).add(key);
+		} else if (localMoved) (localOnly ??= /* @__PURE__ */ new Set()).add(key);
 	}
-	return changedKeys;
+	return remoteChanged || localOnly ? {
+		localOnly,
+		remoteOnly,
+		both,
+		remoteChanged
+	} : NO_PROJECTION_CHANGES;
 }
 function cacheIsEmpty(cached) {
 	return !cached || cached.remoteAttrs === null && cached.inflightAttrs === null && cached.localAttrs === null;
@@ -1205,7 +1274,7 @@ function cacheUpsert(cache, identifier, data, calculateChanges) {
 		cache._capabilities.notifyChange(identifier, "state", null);
 	}
 	const fields = getCacheFields(cache, identifier);
-	if (calculateChanges && existed && data.attributes) changedKeys = calculateChangedKeys(cached, data.attributes, fields);
+	if (calculateChanges && existed && data.attributes) changedKeys = calculateChangedKeys(cached.remoteAttrs, cached.localAttrs, data.attributes, null, fields).remoteChanged;
 	cached.remoteAttrs = Object.assign(cached.remoteAttrs || Object.create(null), data.attributes);
 	if (cached.localAttrs) {
 		if (patchLocalAttributes(cached, changedKeys)) cache._capabilities.notifyChange(identifier, "state", null);
@@ -1309,15 +1378,21 @@ function didCommit(cache, committedIdentifier, data, op) {
 		if (data.relationships) setupRelationships(cache.__graph, fields, identifier, data);
 		newCanonicalAttributes = data.attributes;
 	}
-	const changedKeys = newCanonicalAttributes && calculateChangedKeys(cached, newCanonicalAttributes, fields);
+	const changes = calculateChangedKeys(cached.remoteAttrs, cached.localAttrs, newCanonicalAttributes, cached.inflightAttrs, fields);
 	cached.remoteAttrs = Object.assign(cached.remoteAttrs || Object.create(null), cached.inflightAttrs, newCanonicalAttributes);
 	cached.inflightAttrs = null;
-	patchLocalAttributes(cached, changedKeys);
+	const pruned = patchLocalAttributes(cached, changes.remoteChanged);
 	if (cached.errors) {
 		cached.errors = null;
 		cache._capabilities.notifyChange(identifier, "errors", null);
 	}
-	if (changedKeys?.size) cache._capabilities.notifyChange(identifier, "attributes", changedKeys);
+	const { remoteChanged, localOnly } = changes;
+	const reprune = pruned && remoteChanged !== void 0;
+	const both = reprune ? retainSurviving(changes.both, remoteChanged) : changes.both;
+	const remoteOnly = reprune ? retainSurviving(changes.remoteOnly, remoteChanged) : changes.remoteOnly;
+	if (both?.size) cache._capabilities.notifyChange(identifier, "attributes", both);
+	if (remoteOnly?.size) cache._capabilities.notifyChange(identifier, "attributes", remoteOnly, "remote");
+	if (localOnly?.size) cache._capabilities.notifyChange(identifier, "attributes", localOnly, "local");
 	cache._capabilities.notifyChange(identifier, "state", null);
 }
 function willCommit(cache, identifier) {