@isograph/react 0.0.0-main-03be6563 → 0.0.0-main-7d4bae3e

package/dist/core/areEqualWithDeepComparison.d.ts

@@ -1,4 +1,4 @@
 import type { ReaderAst, ReaderLinkedField, ReaderScalarField } from './reader';
-export declare function areEqualWithDeepComparison(field: ReaderScalarField | ReaderLinkedField, oldItem: unknown, newItem: unknown): boolean;
-export declare function areEqualArraysWithDeepComparison(field: ReaderScalarField | ReaderLinkedField, oldItems: ReadonlyArray<unknown>, newItems: ReadonlyArray<unknown>): boolean;
-export declare function areEqualObjectsWithDeepComparison(ast: ReaderAst<object>, oldItemObject: object, newItemObject: object): boolean;
+export declare function mergeUsingReaderAst(field: ReaderScalarField | ReaderLinkedField, oldItem: unknown, newItem: unknown): unknown;
+export declare function mergeArraysUsingReaderAst(field: ReaderScalarField | ReaderLinkedField, oldItems: ReadonlyArray<unknown>, newItems: Array<unknown>): ReadonlyArray<unknown>;
+export declare function mergeObjectsUsingReaderAst(ast: ReaderAst<object>, oldItemObject: object, newItemObject: object): object;

package/dist/core/areEqualWithDeepComparison.js

@@ -1,27 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.areEqualObjectsWithDeepComparison = exports.areEqualArraysWithDeepComparison = exports.areEqualWithDeepComparison = void 0;
-function areEqualWithDeepComparison(field, oldItem, newItem) {
+exports.mergeObjectsUsingReaderAst = exports.mergeArraysUsingReaderAst = exports.mergeUsingReaderAst = void 0;
+function mergeUsingReaderAst(field, oldItem, newItem) {
     if (newItem === null) {
-        return oldItem === null;
+        return oldItem === null ? oldItem : newItem;
     }
     if (newItem === undefined) {
-        return oldItem === undefined;
+        return oldItem === undefined ? oldItem : newItem;
     }
     if (Array.isArray(newItem)) {
         if (!Array.isArray(oldItem)) {
-            return false;
+            return newItem;
         }
-        return areEqualArraysWithDeepComparison(field, oldItem, newItem);
+        return mergeArraysUsingReaderAst(field, oldItem, newItem);
     }
     switch (field.kind) {
         case 'Scalar':
-            return newItem === oldItem;
+            return oldItem === newItem ? oldItem : newItem;
         case 'Linked':
             if (oldItem == null) {
-                return false;
+                return newItem;
             }
-            return areEqualObjectsWithDeepComparison(field.selections, oldItem, newItem);
+            return mergeObjectsUsingReaderAst(field.selections, oldItem, newItem);
         default: {
             // Ensure we have covered all variants
             let _ = field;
@@ -30,21 +30,27 @@ function areEqualWithDeepComparison(field, oldItem, newItem) {
         }
     }
 }
-exports.areEqualWithDeepComparison = areEqualWithDeepComparison;
-function areEqualArraysWithDeepComparison(field, oldItems, newItems) {
+exports.mergeUsingReaderAst = mergeUsingReaderAst;
+function mergeArraysUsingReaderAst(field, oldItems, newItems) {
     if (newItems.length !== oldItems.length) {
-        return false;
+        return newItems;
     }
+    let canRecycle = true;
     for (let i = 0; i < newItems.length; i++) {
-        if (!areEqualWithDeepComparison(field, oldItems[i], newItems[i])) {
-            return false;
+        const mergedItem = mergeUsingReaderAst(field, oldItems[i], newItems[i]);
+        if (mergedItem !== oldItems[i]) {
+            canRecycle = false;
+        }
+        else {
+            newItems[i] = mergedItem;
         }
     }
-    return true;
+    return canRecycle ? oldItems : newItems;
 }
-exports.areEqualArraysWithDeepComparison = areEqualArraysWithDeepComparison;
-function areEqualObjectsWithDeepComparison(ast, oldItemObject, newItemObject) {
+exports.mergeArraysUsingReaderAst = mergeArraysUsingReaderAst;
+function mergeObjectsUsingReaderAst(ast, oldItemObject, newItemObject) {
     var _a;
+    let canRecycle = true;
     for (const field of ast) {
         switch (field.kind) {
             case 'Scalar':
@@ -54,8 +60,13 @@ function areEqualObjectsWithDeepComparison(ast, oldItemObject, newItemObject) {
                 const oldValue = oldItemObject[key];
                 // @ts-expect-error
                 const newValue = newItemObject[key];
-                if (!areEqualWithDeepComparison(field, oldValue, newValue)) {
-                    return false;
+                const mergedValue = mergeUsingReaderAst(field, oldValue, newValue);
+                if (mergedValue !== oldValue) {
+                    canRecycle = false;
+                }
+                else {
+                    // @ts-expect-error
+                    newItemObject[key] = mergedValue;
                 }
                 break;
             case 'Resolver': {
@@ -65,7 +76,7 @@ function areEqualObjectsWithDeepComparison(ast, oldItemObject, newItemObject) {
                 // @ts-expect-error
                 const newValue = newItemObject[key];
                 if (oldValue !== newValue) {
-                    return false;
+                    canRecycle = false;
                 }
                 break;
             }
@@ -80,6 +91,6 @@ function areEqualObjectsWithDeepComparison(ast, oldItemObject, newItemObject) {
             }
         }
     }
-    return true;
+    return canRecycle ? oldItemObject : newItemObject;
 }
-exports.areEqualObjectsWithDeepComparison = areEqualObjectsWithDeepComparison;
+exports.mergeObjectsUsingReaderAst = mergeObjectsUsingReaderAst;

package/dist/core/cache.js

@@ -158,7 +158,8 @@ function callSubscriptions(environment, recordsEncounteredWhenNormalizing) {
                         suspendIfInFlight: false,
                         throwOnNetworkError: false,
                     });
-                    if (!(0, areEqualWithDeepComparison_1.areEqualObjectsWithDeepComparison)(subscription.readerAst, subscription.encounteredDataAndRecords.item, newEncounteredDataAndRecords.item)) {
+                    const mergedItem = (0, areEqualWithDeepComparison_1.mergeObjectsUsingReaderAst)(subscription.readerAst, subscription.encounteredDataAndRecords.item, newEncounteredDataAndRecords.item);
+                    if (mergedItem !== subscription.encounteredDataAndRecords.item) {
                         // @ts-expect-error
                         if (typeof window !== 'undefined' && window.__LOG) {
                             console.log('Deep equality - No', {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isograph/react",
-  "version": "0.0.0-main-03be6563",
+  "version": "0.0.0-main-7d4bae3e",
   "description": "Use Isograph with React",
   "homepage": "https://isograph.dev",
   "main": "dist/index.js",
@@ -17,9 +17,9 @@
     "tsc": "tsc"
   },
   "dependencies": {
-    "@isograph/disposable-types": "0.0.0-main-03be6563",
-    "@isograph/react-disposable-state": "0.0.0-main-03be6563",
-    "@isograph/reference-counted-pointer": "0.0.0-main-03be6563"
+    "@isograph/disposable-types": "0.0.0-main-7d4bae3e",
+    "@isograph/react-disposable-state": "0.0.0-main-7d4bae3e",
+    "@isograph/reference-counted-pointer": "0.0.0-main-7d4bae3e"
   },
   "peerDependencies": {
     "react": "18.2.0"

package/src/core/areEqualWithDeepComparison.ts

@@ -1,38 +1,34 @@
 import type { ReaderAst, ReaderLinkedField, ReaderScalarField } from './reader';
-export function areEqualWithDeepComparison(
+export function mergeUsingReaderAst(
   field: ReaderScalarField | ReaderLinkedField,
   oldItem: unknown,
   newItem: unknown,
-): boolean {
+): unknown {
   if (newItem === null) {
-    return oldItem === null;
+    return oldItem === null ? oldItem : newItem;
   }
 
   if (newItem === undefined) {
-    return oldItem === undefined;
+    return oldItem === undefined ? oldItem : newItem;
   }
 
   if (Array.isArray(newItem)) {
     if (!Array.isArray(oldItem)) {
-      return false;
+      return newItem;
     }
 
-    return areEqualArraysWithDeepComparison(field, oldItem, newItem);
+    return mergeArraysUsingReaderAst(field, oldItem, newItem);
   }
 
   switch (field.kind) {
     case 'Scalar':
-      return newItem === oldItem;
+      return oldItem === newItem ? oldItem : newItem;
     case 'Linked':
       if (oldItem == null) {
-        return false;
+        return newItem;
       }
 
-      return areEqualObjectsWithDeepComparison(
-        field.selections,
-        oldItem,
-        newItem,
-      );
+      return mergeObjectsUsingReaderAst(field.selections, oldItem, newItem);
     default: {
       // Ensure we have covered all variants
       let _: never = field;
@@ -42,29 +38,34 @@ export function areEqualWithDeepComparison(
   }
 }
 
-export function areEqualArraysWithDeepComparison(
+export function mergeArraysUsingReaderAst(
   field: ReaderScalarField | ReaderLinkedField,
   oldItems: ReadonlyArray<unknown>,
-  newItems: ReadonlyArray<unknown>,
-): boolean {
+  newItems: Array<unknown>,
+): ReadonlyArray<unknown> {
   if (newItems.length !== oldItems.length) {
-    return false;
+    return newItems;
   }
 
+  let canRecycle = true;
   for (let i = 0; i < newItems.length; i++) {
-    if (!areEqualWithDeepComparison(field, oldItems[i], newItems[i])) {
-      return false;
+    const mergedItem = mergeUsingReaderAst(field, oldItems[i], newItems[i]);
+    if (mergedItem !== oldItems[i]) {
+      canRecycle = false;
+    } else {
+      newItems[i] = mergedItem;
     }
   }
 
-  return true;
+  return canRecycle ? oldItems : newItems;
 }
 
-export function areEqualObjectsWithDeepComparison(
+export function mergeObjectsUsingReaderAst(
   ast: ReaderAst<object>,
   oldItemObject: object,
   newItemObject: object,
-): boolean {
+): object {
+  let canRecycle = true;
   for (const field of ast) {
     switch (field.kind) {
       case 'Scalar':
@@ -74,8 +75,13 @@ export function areEqualObjectsWithDeepComparison(
         const oldValue = oldItemObject[key];
         // @ts-expect-error
         const newValue = newItemObject[key];
-        if (!areEqualWithDeepComparison(field, oldValue, newValue)) {
-          return false;
+
+        const mergedValue = mergeUsingReaderAst(field, oldValue, newValue);
+        if (mergedValue !== oldValue) {
+          canRecycle = false;
+        } else {
+          // @ts-expect-error
+          newItemObject[key] = mergedValue;
         }
         break;
       case 'Resolver': {
@@ -86,7 +92,7 @@ export function areEqualObjectsWithDeepComparison(
         const newValue = newItemObject[key];
 
         if (oldValue !== newValue) {
-          return false;
+          canRecycle = false;
         }
         break;
       }
@@ -102,5 +108,5 @@ export function areEqualObjectsWithDeepComparison(
     }
   }
 
-  return true;
+  return canRecycle ? oldItemObject : newItemObject;
 }

package/src/core/cache.ts

@@ -25,7 +25,7 @@ import { ReaderLinkedField, ReaderScalarField, type ReaderAst } from './reader';
 import { Argument, ArgumentValue } from './util';
 import { WithEncounteredRecords, readButDoNotEvaluate } from './read';
 import { FragmentReference, Variables } from './FragmentReference';
-import { areEqualObjectsWithDeepComparison } from './areEqualWithDeepComparison';
+import { mergeObjectsUsingReaderAst } from './areEqualWithDeepComparison';
 import { makeNetworkRequest } from './makeNetworkRequest';
 import { wrapResolvedValue } from './PromiseWrapper';
 
@@ -262,13 +262,12 @@ function callSubscriptions(
               },
             );
 
-            if (
-              !areEqualObjectsWithDeepComparison(
-                subscription.readerAst,
-                subscription.encounteredDataAndRecords.item,
-                newEncounteredDataAndRecords.item,
-              )
-            ) {
+            const mergedItem = mergeObjectsUsingReaderAst(
+              subscription.readerAst,
+              subscription.encounteredDataAndRecords.item,
+              newEncounteredDataAndRecords.item,
+            );
+            if (mergedItem !== subscription.encounteredDataAndRecords.item) {
               // @ts-expect-error
               if (typeof window !== 'undefined' && window.__LOG) {
                 console.log('Deep equality - No', {