fixup! fixup! wip! Implement partial-unordered comparison mode

Author: novemberborn

src/accessors/element.ts

@@ -1,4 +1,4 @@
-import { deeplyEqual, strictlyEqual, unequal } from '../comparison.ts'
+import { deeplyEqual, strictlyEqual, unequal, type Mode } from '../comparison.ts'
 import type { Encoder } from '../encoder.ts'
 import { staticTypeTable } from '../serialization-types.ts'
 import {
@@ -68,10 +68,10 @@ export class ElementAccessor implements CommonRepresentation, DeepFunctionality
     yield this.#value
   }
 
-  compare(other: ValueRepresentation) {
+  compare(other: ValueRepresentation, mode: Mode) {
     if (!(#value in other)) return unequal
     if (this.#index !== other.#index) return unequal
-    return this.#value.compare(other.#value)
+    return this.#value.compare(other.#value, mode)
   }
 
   finalFormat(formatter: Formatter): void {

src/accessors/iterator-value.ts

@@ -1,4 +1,4 @@
-import { unequal } from '../comparison.ts'
+import { unequal, type Mode } from '../comparison.ts'
 import { partial, type SerializationResult } from '../serialization-result.ts'
 import type { Encoder } from '../encoder.ts'
 import type {
@@ -31,10 +31,10 @@ export class IteratorValueAccessor implements CommonRepresentation, DeepFunction
     yield this.#value
   }
 
-  compare(other: ValueRepresentation) {
+  compare(other: ValueRepresentation, mode: Mode) {
     if (!(#value in other)) return unequal
     if (this.#index !== other.#index) return unequal
-    return this.#value.compare(other.#value)
+    return this.#value.compare(other.#value, mode)
   }
 
   finalFormat(formatter: Formatter): void {

src/accessors/map-entry.ts

@@ -1,5 +1,5 @@
 import never from 'never'
-import { possiblyEqual, strictlyEqual, unequal } from '../comparison.ts'
+import { possiblyEqual, strictlyEqual, unequal, type Mode } from '../comparison.ts'
 import { DeserializationContext } from '../deserialization-context.ts'
 import { type SerializationResult, partial } from '../serialization-result.ts'
 import type {
@@ -44,13 +44,15 @@ export class MapEntryAccessor implements CommonRepresentation, DeepFunctionality
     yield this.#value
   }
 
-  compare(other: ValueRepresentation) {
+  compare(other: ValueRepresentation, mode: Mode) {
     if (!(#value in other)) return unequal
 
-    const keyComparison = this.#key.compare(other.#key)
+    // Always compare keys in full mode; allowing keys to be partially equal
+    // will make it impossible to distinguish between different map entries.
+    const keyComparison = this.#key.compare(other.#key, 'full')
     if (keyComparison !== strictlyEqual && keyComparison !== possiblyEqual) return keyComparison
 
-    return this.#value.compare(other.#value)
+    return this.#value.compare(other.#value, mode)
   }
 
   formatAfterIteration(formatter: Formatter, value: ValueRepresentation): void {

src/accessors/property.ts

@@ -1,4 +1,4 @@
-import { type Comparison, comparable, strictlyEqual, unequal, possiblyEqual } from '../comparison.ts'
+import { type Comparison, comparable, strictlyEqual, unequal, possiblyEqual, type Mode } from '../comparison.ts'
 import type { Encoder } from '../encoder.ts'
 import { type SerializationResult, partial } from '../serialization-result.ts'
 import type {
@@ -36,11 +36,11 @@ export class NamedPropertyAccessor implements CommonRepresentation, DeepFunction
     yield this.#value
   }
 
-  compare(other: ValueRepresentation): Comparison {
+  compare(other: ValueRepresentation, mode: Mode): Comparison {
     if (!(#value in other)) return unequal
     if (this.#key !== other.#key) return unequal
 
-    return this.#value.compare(other.#value)
+    return this.#value.compare(other.#value, mode)
   }
 
   preformat(formatter: Formatter) {
@@ -135,12 +135,12 @@ export class SymbolPropertyAccessor implements CommonRepresentation, DeepFunctio
     return new SymbolPropertyGroup(properties)
   }
 
-  compare(other: ValueRepresentation): Comparison {
+  compare(other: ValueRepresentation, mode: Mode): Comparison {
     if (!(#value in other)) return unequal
     const comparison = this.#key.compare(other.#key)
     if (comparison !== strictlyEqual && comparison !== possiblyEqual) return unequal
 
-    return this.#value.compare(other.#value)
+    return this.#value.compare(other.#value, mode)
   }
 
   preformat(formatter: Formatter) {

src/accessors/test/element.ts

@@ -108,7 +108,7 @@ test('ElementAccessor - compare returns unequal for non-ElementAccessor', (t) =>
     },
   }
 
-  t.is(element.compare(nonElement as unknown as ValueRepresentation), unequal)
+  t.is(element.compare(nonElement as unknown as ValueRepresentation, 'full'), unequal)
 })
 
 test('ElementAccessor - compare returns unequal for different indices', (t) => {
@@ -117,7 +117,7 @@ test('ElementAccessor - compare returns unequal for different indices', (t) => {
   const element1 = new ElementAccessor(5, value)
   const element2 = new ElementAccessor(10, value)
 
-  t.is(element1.compare(element2), unequal)
+  t.is(element1.compare(element2, 'full'), unequal)
 })
 
 test('ElementAccessor - compare delegates to value comparison when indices match', (t) => {
@@ -128,12 +128,12 @@ test('ElementAccessor - compare delegates to value comparison when indices match
   const element2 = new ElementAccessor(5, value2)
 
   // Should return whatever the string comparison returns (unequal in this case)
-  t.is(element1.compare(element2), unequal)
+  t.is(element1.compare(element2, 'full'), unequal)
 
   // When values are equal
   const value3 = new StringRepresentation('test')
   const element3 = new ElementAccessor(5, value3)
-  t.is(element1.compare(element3), strictlyEqual)
+  t.is(element1.compare(element3, 'full'), strictlyEqual)
 })
 
 test('ElementAccessor - serialize delegates to value serializeShallow if available', (t) => {
@@ -196,7 +196,7 @@ test('ElementAccessor - handles complex nesting', (t) => {
   const outer2 = new ElementAccessor(1, inner2)
 
   // Deep comparison should work
-  t.is(outer.compare(outer2), strictlyEqual)
+  t.is(outer.compare(outer2, 'full'), strictlyEqual)
 })
 
 test('ElementAccessor - finalFormat appends theme.element.after to formatter', (t) => {

src/accessors/test/iterator-value.ts

@@ -57,7 +57,7 @@ test('compare returns unequal for non-IteratorValueAccessor', (t) => {
     },
   }
 
-  t.is(iteratorValue.compare(nonIteratorValue as unknown as ValueRepresentation), unequal)
+  t.is(iteratorValue.compare(nonIteratorValue as unknown as ValueRepresentation, 'full'), unequal)
 })
 
 test('compare returns unequal for different indices', (t) => {
@@ -66,7 +66,7 @@ test('compare returns unequal for different indices', (t) => {
   const iteratorValue1 = new IteratorValueAccessor(5, value)
   const iteratorValue2 = new IteratorValueAccessor(10, value)
 
-  t.is(iteratorValue1.compare(iteratorValue2), unequal)
+  t.is(iteratorValue1.compare(iteratorValue2, 'full'), unequal)
 })
 
 test('compare delegates to value comparison when indices match', (t) => {
@@ -77,12 +77,12 @@ test('compare delegates to value comparison when indices match', (t) => {
   const iteratorValue2 = new IteratorValueAccessor(5, value2)
 
   // Should return whatever the string comparison returns (unequal in this case)
-  t.is(iteratorValue1.compare(iteratorValue2), unequal)
+  t.is(iteratorValue1.compare(iteratorValue2, 'full'), unequal)
 
   // When values are equal
   const value3 = new StringRepresentation('test')
   const iteratorValue3 = new IteratorValueAccessor(5, value3)
-  t.is(iteratorValue1.compare(iteratorValue3), strictlyEqual)
+  t.is(iteratorValue1.compare(iteratorValue3, 'full'), strictlyEqual)
 })
 
 // Test serialize
@@ -139,10 +139,10 @@ test('works with primitive values', (t) => {
 
   // Comparison
   const iteratorValue2 = new IteratorValueAccessor(0, new NumberRepresentation(42))
-  t.is(iteratorValue.compare(iteratorValue2), strictlyEqual)
+  t.is(iteratorValue.compare(iteratorValue2, 'full'), strictlyEqual)
 
   const iteratorValue3 = new IteratorValueAccessor(0, new NumberRepresentation(43))
-  t.is(iteratorValue.compare(iteratorValue3), unequal)
+  t.is(iteratorValue.compare(iteratorValue3, 'full'), unequal)
 })
 
 test('handles nested iterator values', (t) => {
@@ -164,7 +164,7 @@ test('handles nested iterator values', (t) => {
   const outer2 = new IteratorValueAccessor(1, inner2)
 
   // Deep comparison should work
-  t.is(outer.compare(outer2), strictlyEqual)
+  t.is(outer.compare(outer2, 'full'), strictlyEqual)
 })
 
 // Test finalFormat

src/accessors/test/map-entry.ts

@@ -91,7 +91,7 @@ test('compare returns unequal for non-MapEntryAccessor', (t) => {
     },
   }
 
-  t.is(mapEntry.compare(nonMapEntry as unknown as ValueRepresentation), unequal)
+  t.is(mapEntry.compare(nonMapEntry as unknown as ValueRepresentation, 'full'), unequal)
 })
 
 test('compare returns key comparison result when keys are not equal', (t) => {
@@ -106,7 +106,7 @@ test('compare returns key comparison result when keys are not equal', (t) => {
   const mapEntry2 = new MapEntryAccessor(context, key2, value2)
 
   // Should return the result of comparing keys (unequal in this case)
-  t.is(mapEntry1.compare(mapEntry2), unequal)
+  t.is(mapEntry1.compare(mapEntry2, 'full'), unequal)
 })
 
 test('compare returns value comparison result when keys are equal', (t) => {
@@ -122,14 +122,14 @@ test('compare returns value comparison result when keys are equal', (t) => {
   const mapEntry2 = new MapEntryAccessor(context, sameKey, value2)
 
   // Keys are strictly equal, so should return result of value comparison
-  t.is(mapEntry1.compare(mapEntry2), unequal)
+  t.is(mapEntry1.compare(mapEntry2, 'full'), unequal)
 
   // Try with equal values too
   const value3 = new StringRepresentation('value1')
   const mapEntry3 = new MapEntryAccessor(context, sameKey, value3)
 
   // Both keys and values are strictly equal
-  t.is(mapEntry1.compare(mapEntry3), strictlyEqual)
+  t.is(mapEntry1.compare(mapEntry3, 'full'), strictlyEqual)
 })
 
 test('compare handles strictlyEqual keys across contexts', (t) => {
@@ -147,7 +147,7 @@ test('compare handles strictlyEqual keys across contexts', (t) => {
 
   // Keys should be strictly equal because they have the same content
   // Values are also strictly equal
-  t.is(mapEntry1.compare(mapEntry2), strictlyEqual)
+  t.is(mapEntry1.compare(mapEntry2, 'full'), strictlyEqual)
 })
 
 test('compare handles possiblyEqual keys correctly', (t) => {
@@ -180,14 +180,14 @@ test('compare handles possiblyEqual keys correctly', (t) => {
   const mapEntry2 = new MapEntryAccessor(deserializationContext, key2!, value2)
 
   // Keys are possiblyEqual but values are unequal
-  t.is(mapEntry1.compare(mapEntry2), unequal)
+  t.is(mapEntry1.compare(mapEntry2, 'full'), unequal)
 
   // Same value content
   const value3 = new StringRepresentation('value1')
   const mapEntry3 = new MapEntryAccessor(deserializationContext, key2!, value3)
 
   // Now with equal values, result should match the value comparison
-  t.is(mapEntry1.compare(mapEntry3), strictlyEqual)
+  t.is(mapEntry1.compare(mapEntry3, 'full'), strictlyEqual)
 })
 
 // Test serialize

src/accessors/test/property.ts

@@ -45,7 +45,7 @@ test('NamedPropertyAccessor - compare returns unequal for non-NamedPropertyAcces
   const value = new StringRepresentation('value')
   const property = new NamedPropertyAccessor(key, value)
 
-  t.is(property.compare(value), unequal)
+  t.is(property.compare(value, 'full'), unequal)
 })
 
 test('NamedPropertyAccessor - compare returns unequal for different keys', (t) => {
@@ -54,7 +54,7 @@ test('NamedPropertyAccessor - compare returns unequal for different keys', (t) =
   const property1 = new NamedPropertyAccessor('prop1', value)
   const property2 = new NamedPropertyAccessor('prop2', value)
 
-  t.is(property1.compare(property2), unequal)
+  t.is(property1.compare(property2, 'full'), unequal)
 })
 
 test('NamedPropertyAccessor - compare delegates to value comparison when keys match', (t) => {
@@ -66,12 +66,12 @@ test('NamedPropertyAccessor - compare delegates to value comparison when keys ma
   const property2 = new NamedPropertyAccessor(key, value2)
 
   // Should return result of comparing values (unequal in this case)
-  t.is(property1.compare(property2), unequal)
+  t.is(property1.compare(property2, 'full'), unequal)
 
   // When values are equal
   const value3 = new StringRepresentation('value1')
   const property3 = new NamedPropertyAccessor(key, value3)
-  t.is(property1.compare(property3), strictlyEqual)
+  t.is(property1.compare(property3, 'full'), strictlyEqual)
 })
 
 test('NamedPropertyAccessor - serialize encodes key as string and delegates to value.serializeShallow', (t) => {
@@ -223,7 +223,7 @@ test('SymbolPropertyAccessor - compare returns unequal for non-SymbolPropertyAcc
 
   const property = new SymbolPropertyAccessor(key, value)
 
-  t.is(property.compare(value), unequal)
+  t.is(property.compare(value, 'full'), unequal)
 })
 
 test('SymbolPropertyAccessor - compare returns unequal for different symbol keys', (t) => {
@@ -240,7 +240,7 @@ test('SymbolPropertyAccessor - compare returns unequal for different symbol keys
   const property1 = new SymbolPropertyAccessor(key1, value)
   const property2 = new SymbolPropertyAccessor(key2, value)
 
-  t.is(property1.compare(property2), unequal)
+  t.is(property1.compare(property2, 'full'), unequal)
 })
 
 test('SymbolPropertyAccessor - compare delegates to value comparison when symbol keys match', (t) => {
@@ -257,12 +257,12 @@ test('SymbolPropertyAccessor - compare delegates to value comparison when symbol
   const property2 = new SymbolPropertyAccessor(key, value2)
 
   // Should return result of comparing values (unequal in this case)
-  t.is(property1.compare(property2), unequal)
+  t.is(property1.compare(property2, 'full'), unequal)
 
   // When values are equal
   const value3 = new StringRepresentation('value1')
   const property3 = new SymbolPropertyAccessor(key, value3)
-  t.is(property1.compare(property3), strictlyEqual)
+  t.is(property1.compare(property3, 'full'), strictlyEqual)
 })
 
 test('SymbolPropertyAccessor - serialize encodes key and returns partial', (t) => {
@@ -542,13 +542,14 @@ test('NamedPropertyGroup - iterator loads properties from DeserializationContext
 
   // Find and verify prop1
   const foundProp1 = properties.find(
-    (prop) => prop.compare(new NamedPropertyAccessor('prop1', new StringRepresentation('value1'))) === strictlyEqual,
+    (prop) =>
+      prop.compare(new NamedPropertyAccessor('prop1', new StringRepresentation('value1')), 'full') === strictlyEqual,
   )
   t.truthy(foundProp1, 'Should find property with key "prop1" and value "value1"')
 
   // Find and verify prop2
   const foundProp2 = properties.find(
-    (prop) => prop.compare(new NamedPropertyAccessor('prop2', new NumberRepresentation(42))) === strictlyEqual,
+    (prop) => prop.compare(new NamedPropertyAccessor('prop2', new NumberRepresentation(42)), 'full') === strictlyEqual,
   )
   t.truthy(foundProp2, 'Should find property with key "prop2" and value 42')
 })

src/test/compare.ts

@@ -1,7 +1,7 @@
 import { mock } from 'node:test'
 import test from 'ava'
 import { compare, compareRepresentations } from '../compare.ts'
-import { comparable, deeplyEqual, unequal, strictlyEqual, type Comparison } from '../comparison.ts'
+import { comparable, deeplyEqual, unequal, strictlyEqual, type Comparison, type Mode } from '../comparison.ts'
 import { finished, type SerializationResult } from '../serialization-result.ts'
 import type {
   AccessorFunctionality,
@@ -23,7 +23,7 @@ class MockValueRepresentation implements CommonRepresentation, DeepFunctionality
     this.children = children
   }
 
-  compare(): Comparison {
+  compare(_other: ValueRepresentation, _mode: Mode): Comparison {
     return this.#compareResult
   }
 
@@ -156,6 +156,14 @@ test('compare passes complex objects to compareDescriptors', (t) => {
 })
 
 // Tests for compareDescriptors() function
+test('compareDescriptors mode defaults to "full"', (t) => {
+  const lhs = new MockValueRepresentation(comparable)
+  const spy = mock.method(lhs, 'compare')
+  const rhs = new MockValueRepresentation(comparable)
+  compareRepresentations(lhs, rhs)
+  t.is(spy.mock.calls[0]?.arguments[1], 'full', 'Default mode should be "full"')
+})
+
 test('compareDescriptors returns true when both value representations are deeply equal', (t) => {
   const lhs = new MockValueRepresentation(deeplyEqual)
   const rhs = new MockValueRepresentation(deeplyEqual)