@isograph/react 0.0.0-main-7e245bae → 0.0.0-main-04cbf235

package/dist/core/areEqualWithDeepComparison.d.ts

@@ -1,3 +1,4 @@
-export declare function areEqualWithDeepComparison(oldItem: unknown, newItem: unknown): boolean;
-export declare function areEqualArraysWithDeepComparison(oldItems: ReadonlyArray<unknown>, newItems: ReadonlyArray<unknown>): boolean;
-export declare function areEqualObjectsWithDeepComparison(oldItemObject: object, newItemObject: object): boolean;
+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;

package/dist/core/areEqualWithDeepComparison.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.areEqualObjectsWithDeepComparison = exports.areEqualArraysWithDeepComparison = exports.areEqualWithDeepComparison = void 0;
-function areEqualWithDeepComparison(oldItem, newItem) {
+function areEqualWithDeepComparison(field, oldItem, newItem) {
     if (newItem === null) {
         return oldItem === null;
     }
@@ -12,48 +12,72 @@ function areEqualWithDeepComparison(oldItem, newItem) {
         if (!Array.isArray(oldItem)) {
             return false;
         }
-        return areEqualArraysWithDeepComparison(oldItem, newItem);
+        return areEqualArraysWithDeepComparison(field, oldItem, newItem);
     }
-    if (typeof newItem === 'object') {
-        if (typeof oldItem !== 'object') {
-            return false;
-        }
-        if (oldItem === null) {
-            return false;
+    switch (field.kind) {
+        case 'Scalar':
+            return newItem === oldItem;
+        case 'Linked':
+            if (oldItem == null) {
+                return false;
+            }
+            return areEqualObjectsWithDeepComparison(field.selections, oldItem, newItem);
+        default: {
+            // Ensure we have covered all variants
+            let _ = field;
+            _;
+            throw new Error('Unexpected case.');
         }
-        return areEqualObjectsWithDeepComparison(oldItem, newItem);
     }
-    return newItem === oldItem;
 }
 exports.areEqualWithDeepComparison = areEqualWithDeepComparison;
-function areEqualArraysWithDeepComparison(oldItems, newItems) {
+function areEqualArraysWithDeepComparison(field, oldItems, newItems) {
     if (newItems.length !== oldItems.length) {
         return false;
     }
     for (let i = 0; i < newItems.length; i++) {
-        if (!areEqualWithDeepComparison(oldItems[i], newItems[i])) {
+        if (!areEqualWithDeepComparison(field, oldItems[i], newItems[i])) {
             return false;
         }
     }
     return true;
 }
 exports.areEqualArraysWithDeepComparison = areEqualArraysWithDeepComparison;
-function areEqualObjectsWithDeepComparison(oldItemObject, newItemObject) {
-    const oldKeys = Object.keys(oldItemObject);
-    const newKeys = Object.keys(newItemObject);
-    if (oldKeys.length !== newKeys.length) {
-        return false;
-    }
-    for (const oldKey of oldKeys) {
-        if (!(oldKey in newItemObject)) {
-            return false;
-        }
-        // @ts-expect-error
-        const oldValue = oldItemObject[oldKey];
-        // @ts-expect-error
-        const newValue = newItemObject[oldKey];
-        if (!areEqualWithDeepComparison(oldValue, newValue)) {
-            return false;
+function areEqualObjectsWithDeepComparison(ast, oldItemObject, newItemObject) {
+    var _a;
+    for (const field of ast) {
+        switch (field.kind) {
+            case 'Scalar':
+            case 'Linked':
+                const key = (_a = field.alias) !== null && _a !== void 0 ? _a : field.fieldName;
+                // @ts-expect-error
+                const oldValue = oldItemObject[key];
+                // @ts-expect-error
+                const newValue = newItemObject[key];
+                if (!areEqualWithDeepComparison(field, oldValue, newValue)) {
+                    return false;
+                }
+                break;
+            case 'Resolver': {
+                const key = field.alias;
+                // @ts-expect-error
+                const oldValue = oldItemObject[key];
+                // @ts-expect-error
+                const newValue = newItemObject[key];
+                if (oldValue !== newValue) {
+                    return false;
+                }
+                break;
+            }
+            case 'ImperativelyLoadedField':
+            case 'LoadablySelectedField':
+                break;
+            default: {
+                // Ensure we have covered all variants
+                let _ = field;
+                _;
+                throw new Error('Unexpected case.');
+            }
         }
     }
     return true;

package/dist/core/cache.js

@@ -158,7 +158,7 @@ function callSubscriptions(environment, recordsEncounteredWhenNormalizing) {
                         suspendIfInFlight: false,
                         throwOnNetworkError: false,
                     });
-                    if (!(0, areEqualWithDeepComparison_1.areEqualObjectsWithDeepComparison)(subscription.encounteredDataAndRecords.item, newEncounteredDataAndRecords.item)) {
+                    if (!(0, areEqualWithDeepComparison_1.areEqualObjectsWithDeepComparison)(subscription.readerAst, subscription.encounteredDataAndRecords.item, newEncounteredDataAndRecords.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-7e245bae",
+  "version": "0.0.0-main-04cbf235",
   "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-7e245bae",
-    "@isograph/react-disposable-state": "0.0.0-main-7e245bae",
-    "@isograph/reference-counted-pointer": "0.0.0-main-7e245bae"
+    "@isograph/disposable-types": "0.0.0-main-04cbf235",
+    "@isograph/react-disposable-state": "0.0.0-main-04cbf235",
+    "@isograph/reference-counted-pointer": "0.0.0-main-04cbf235"
   },
   "peerDependencies": {
     "react": "18.2.0"

package/src/core/areEqualWithDeepComparison.ts

@@ -1,4 +1,6 @@
+import type { ReaderAst, ReaderLinkedField, ReaderScalarField } from './reader';
 export function areEqualWithDeepComparison(
+  field: ReaderScalarField | ReaderLinkedField,
   oldItem: unknown,
   newItem: unknown,
 ): boolean {
@@ -15,25 +17,33 @@ export function areEqualWithDeepComparison(
       return false;
     }
 
-    return areEqualArraysWithDeepComparison(oldItem, newItem);
+    return areEqualArraysWithDeepComparison(field, oldItem, newItem);
   }
 
-  if (typeof newItem === 'object') {
-    if (typeof oldItem !== 'object') {
-      return false;
-    }
+  switch (field.kind) {
+    case 'Scalar':
+      return newItem === oldItem;
+    case 'Linked':
+      if (oldItem == null) {
+        return false;
+      }
 
-    if (oldItem === null) {
-      return false;
+      return areEqualObjectsWithDeepComparison(
+        field.selections,
+        oldItem,
+        newItem,
+      );
+    default: {
+      // Ensure we have covered all variants
+      let _: never = field;
+      _;
+      throw new Error('Unexpected case.');
     }
-
-    return areEqualObjectsWithDeepComparison(oldItem, newItem);
   }
-
-  return newItem === oldItem;
 }
 
 export function areEqualArraysWithDeepComparison(
+  field: ReaderScalarField | ReaderLinkedField,
   oldItems: ReadonlyArray<unknown>,
   newItems: ReadonlyArray<unknown>,
 ): boolean {
@@ -42,7 +52,7 @@ export function areEqualArraysWithDeepComparison(
   }
 
   for (let i = 0; i < newItems.length; i++) {
-    if (!areEqualWithDeepComparison(oldItems[i], newItems[i])) {
+    if (!areEqualWithDeepComparison(field, oldItems[i], newItems[i])) {
       return false;
     }
   }
@@ -51,28 +61,46 @@ export function areEqualArraysWithDeepComparison(
 }
 
 export function areEqualObjectsWithDeepComparison(
+  ast: ReaderAst<object>,
   oldItemObject: object,
   newItemObject: object,
 ): boolean {
-  const oldKeys = Object.keys(oldItemObject);
-  const newKeys = Object.keys(newItemObject);
+  for (const field of ast) {
+    switch (field.kind) {
+      case 'Scalar':
+      case 'Linked':
+        const key = field.alias ?? field.fieldName;
+        // @ts-expect-error
+        const oldValue = oldItemObject[key];
+        // @ts-expect-error
+        const newValue = newItemObject[key];
+        if (!areEqualWithDeepComparison(field, oldValue, newValue)) {
+          return false;
+        }
+        break;
+      case 'Resolver': {
+        const key = field.alias;
+        // @ts-expect-error
+        const oldValue = oldItemObject[key];
+        // @ts-expect-error
+        const newValue = newItemObject[key];
 
-  if (oldKeys.length !== newKeys.length) {
-    return false;
-  }
-
-  for (const oldKey of oldKeys) {
-    if (!(oldKey in newItemObject)) {
-      return false;
-    }
-    // @ts-expect-error
-    const oldValue = oldItemObject[oldKey];
-    // @ts-expect-error
-    const newValue = newItemObject[oldKey];
-
-    if (!areEqualWithDeepComparison(oldValue, newValue)) {
-      return false;
+        if (oldValue !== newValue) {
+          return false;
+        }
+        break;
+      }
+      case 'ImperativelyLoadedField':
+      case 'LoadablySelectedField':
+        break;
+      default: {
+        // Ensure we have covered all variants
+        let _: never = field;
+        _;
+        throw new Error('Unexpected case.');
+      }
     }
   }
+
   return true;
 }

package/src/core/cache.ts

@@ -264,6 +264,7 @@ function callSubscriptions(
 
             if (
               !areEqualObjectsWithDeepComparison(
+                subscription.readerAst,
                 subscription.encounteredDataAndRecords.item,
                 newEncounteredDataAndRecords.item,
               )