feat(core): add compare util

.nvmrc

@@ -1 +1 @@
-24.8.0
+26.10.0

docs/reference/functions/compareDeep.md

@@ -0,0 +1,30 @@
+---
+id: compareDeep
+title: compareDeep
+---
+
+```ts
+function compareDeep<T>(objA, objB): boolean;
+```
+
+Defined in: [compare.ts:5](https://github.com/TanStack/store/blob/main/packages/store/src/compare.ts#L5)
+
+## Type Parameters
+
+### T
+
+`T`
+
+## Parameters
+
+### objA
+
+`T`
+
+### objB
+
+`T`
+
+## Returns
+
+`boolean`

docs/reference/functions/compareShallow.md

@@ -0,0 +1,30 @@
+---
+id: compareShallow
+title: compareShallow
+---
+
+```ts
+function compareShallow<T>(objA, objB): boolean;
+```
+
+Defined in: [compare.ts:1](https://github.com/TanStack/store/blob/main/packages/store/src/compare.ts#L1)
+
+## Type Parameters
+
+### T
+
+`T`
+
+## Parameters
+
+### objA
+
+`T`
+
+### objB
+
+`T`
+
+## Returns
+
+`boolean`

docs/reference/index.md

@@ -33,6 +33,8 @@ title: "@tanstack/store"
 ## Functions
 
 - [batch](functions/batch.md)
+- [compareDeep](functions/compareDeep.md)
+- [compareShallow](functions/compareShallow.md)
 - [createAsyncAtom](functions/createAsyncAtom.md)
 - [createAtom](functions/createAtom.md)
 - [createStore](functions/createStore.md)

package.json

@@ -49,7 +49,7 @@
     "@tanstack/typedoc-config": "0.3.3",
     "@testing-library/jest-dom": "^6.9.1",
     "@testing-library/user-event": "^14.6.1",
-    "@types/node": "^25.6.0",
+    "@types/node": "^26.6.0",
     "@vitest/coverage-istanbul": "^4.1.4",
     "eslint": "^10.2.0",
     "eslint-plugin-react-hooks": "^7.0.1",

packages/react-store/tests/index.test.tsx

@@ -11,8 +11,8 @@ import { describe, expect, it, test, vi } from 'vitest'
 import { createAtom, createStore } from '@tanstack/store'
 import {
   _useStore,
+  compareShallow,
   createStoreContext,
-  shallow,
   useAtom,
   useCreateAtom,
   useCreateStore,
@@ -748,66 +748,66 @@ describe('shallow', () => {
   test('should return true for shallowly equal objects', () => {
     const objA = { a: 1, b: 'hello' }
     const objB = { a: 1, b: 'hello' }
-    expect(shallow(objA, objB)).toBe(true)
+    expect(compareShallow(objA, objB)).toBe(true)
   })
 
   test('should return false for objects with different values', () => {
     const objA = { a: 1, b: 'hello' }
     const objB = { a: 2, b: 'world' }
-    expect(shallow(objA, objB)).toBe(false)
+    expect(compareShallow(objA, objB)).toBe(false)
   })
 
   test('should return false for objects with different keys', () => {
     const objA = { a: 1, b: 'hello' }
     const objB = { a: 1, c: 'world' }
     // @ts-expect-error
-    expect(shallow(objA, objB)).toBe(false)
+    expect(compareShallow(objA, objB)).toBe(false)
   })
 
   test('should return false for objects with different structures', () => {
     const objA = { a: 1, b: 'hello' }
     const objB = [1, 'hello']
     // @ts-expect-error
-    expect(shallow(objA, objB)).toBe(false)
+    expect(compareShallow(objA, objB)).toBe(false)
   })
 
   test('should return false for one object being null', () => {
     const objA = { a: 1, b: 'hello' }
     const objB = null
-    expect(shallow(objA, objB)).toBe(false)
+    expect(compareShallow(objA, objB)).toBe(false)
   })
 
   test('should return false for one object being undefined', () => {
     const objA = { a: 1, b: 'hello' }
     const objB = undefined
-    expect(shallow(objA, objB)).toBe(false)
+    expect(compareShallow(objA, objB)).toBe(false)
   })
 
   test('should return true for two null objects', () => {
     const objA = null
     const objB = null
-    expect(shallow(objA, objB)).toBe(true)
+    expect(compareShallow(objA, objB)).toBe(true)
   })
 
   test('should return false for objects with different types', () => {
     const objA = { a: 1, b: 'hello' }
     const objB = { a: '1', b: 'hello' }
     // @ts-expect-error
-    expect(shallow(objA, objB)).toBe(false)
+    expect(compareShallow(objA, objB)).toBe(false)
   })
 
   test('should return true for shallow equal objects with symbol keys', () => {
     const sym = Symbol.for('key')
     const objA = { [sym]: 1 }
     const objB = { [sym]: 1 }
-    expect(shallow(objA, objB)).toBe(true)
+    expect(compareShallow(objA, objB)).toBe(true)
   })
 
   test('should return false for shallow different values for symbol keys', () => {
     const sym = Symbol.for('key')
     const objA = { [sym]: 1 }
     const objB = { [sym]: 2 }
-    expect(shallow(objA, objB)).toBe(false)
+    expect(compareShallow(objA, objB)).toBe(false)
   })
 
   test('should return true for non-enumerable keys', () => {
@@ -824,7 +824,7 @@ describe('shallow', () => {
       value: 2,
     })
 
-    expect(shallow(objA, objB)).toBe(true)
+    expect(compareShallow(objA, objB)).toBe(true)
   })
 
   test('should handle arrays inside of a useSelector', async () => {

packages/solid-store/tests/index.test.tsx

@@ -3,8 +3,8 @@ import { render, renderHook } from '@solidjs/testing-library'
 import { createAtom, createStore } from '@tanstack/store'
 import {
   _useStore,
+  compareShallow,
   createStoreContext,
-  shallow,
   useAtom,
   useSelector,
   useStore,
@@ -263,101 +263,101 @@ describe('shallow', () => {
   test('should return true for shallowly equal objects', () => {
     const objA = { a: 1, b: 'hello' }
     const objB = { a: 1, b: 'hello' }
-    expect(shallow(objA, objB)).toBe(true)
+    expect(compareShallow(objA, objB)).toBe(true)
   })
 
   test('should return false for objects with different values', () => {
     const objA = { a: 1, b: 'hello' }
     const objB = { a: 2, b: 'world' }
-    expect(shallow(objA, objB)).toBe(false)
+    expect(compareShallow(objA, objB)).toBe(false)
   })
 
   test('should return false for objects with different keys', () => {
     const objA = { a: 1, b: 'hello' }
     const objB = { a: 1, c: 'world' }
     // @ts-expect-error
-    expect(shallow(objA, objB)).toBe(false)
+    expect(compareShallow(objA, objB)).toBe(false)
   })
 
   test('should return false for objects with different structures', () => {
     const objA = { a: 1, b: 'hello' }
     const objB = [1, 'hello']
     // @ts-expect-error
-    expect(shallow(objA, objB)).toBe(false)
+    expect(compareShallow(objA, objB)).toBe(false)
   })
 
   test('should return false for one object being null', () => {
     const objA = { a: 1, b: 'hello' }
     const objB = null
-    expect(shallow(objA, objB)).toBe(false)
+    expect(compareShallow(objA, objB)).toBe(false)
   })
 
   test('should return false for one object being undefined', () => {
     const objA = { a: 1, b: 'hello' }
     const objB = undefined
-    expect(shallow(objA, objB)).toBe(false)
+    expect(compareShallow(objA, objB)).toBe(false)
   })
 
   test('should return true for two null objects', () => {
     const objA = null
     const objB = null
-    expect(shallow(objA, objB)).toBe(true)
+    expect(compareShallow(objA, objB)).toBe(true)
   })
 
   test('should return false for objects with different types', () => {
     const objA = { a: 1, b: 'hello' }
     const objB = { a: '1', b: 'hello' }
     // @ts-expect-error
-    expect(shallow(objA, objB)).toBe(false)
+    expect(compareShallow(objA, objB)).toBe(false)
   })
 
   test('should return true for shallow equal objects with symbol keys', () => {
     const sym = Symbol.for('key')
     const objA = { [sym]: 1 }
     const objB = { [sym]: 1 }
-    expect(shallow(objA, objB)).toBe(true)
+    expect(compareShallow(objA, objB)).toBe(true)
   })
 
   test('should return false for shallow different values for symbol keys', () => {
     const sym = Symbol.for('key')
     const objA = { [sym]: 1 }
     const objB = { [sym]: 2 }
-    expect(shallow(objA, objB)).toBe(false)
+    expect(compareShallow(objA, objB)).toBe(false)
   })
 
   test('should return true for shallowly equal maps', () => {
     const objA = new Map([['1', 'hello']])
     const objB = new Map([['1', 'hello']])
-    expect(shallow(objA, objB)).toBe(true)
+    expect(compareShallow(objA, objB)).toBe(true)
   })
 
   test('should return false for maps with different values', () => {
     const objA = new Map([['1', 'hello']])
     const objB = new Map([['1', 'world']])
-    expect(shallow(objA, objB)).toBe(false)
+    expect(compareShallow(objA, objB)).toBe(false)
   })
 
   test('should return true for shallowly equal sets', () => {
     const objA = new Set([1])
     const objB = new Set([1])
-    expect(shallow(objA, objB)).toBe(true)
+    expect(compareShallow(objA, objB)).toBe(true)
   })
 
   test('should return false for sets with different values', () => {
     const objA = new Set([1])
     const objB = new Set([2])
-    expect(shallow(objA, objB)).toBe(false)
+    expect(compareShallow(objA, objB)).toBe(false)
   })
 
   test('should return false for dates with different values', () => {
     const objA = new Date('2025-04-10T14:48:00')
     const objB = new Date('2025-04-10T14:58:00')
-    expect(shallow(objA, objB)).toBe(false)
+    expect(compareShallow(objA, objB)).toBe(false)
   })
 
   test('should return true for equal dates', () => {
     const objA = new Date('2025-02-10')
     const objB = new Date('2025-02-10')
-    expect(shallow(objA, objB)).toBe(true)
+    expect(compareShallow(objA, objB)).toBe(true)
   })
 })