cleanup

packages/system/src/RequestMerger.ts

@@ -1,6 +1,5 @@
 import { ReqFilter } from ".";
 import { FlatReqFilter } from "./RequestExpander";
-import { distance } from "./Util";
 
 /**
  * Keys which can change the entire meaning of the filter outside the array types
@@ -17,7 +16,70 @@ export function canMergeFilters(a: FlatReqFilter | ReqFilter, b: FlatReqFilter |
       }
     }
   }
-  return distance(aObj, bObj) <= 1;
+  let flag = false;
+  if (!equalProp(a.ids, b.ids)) {
+    flag = true;
+  }
+  if (!equalProp(a.authors, b.authors)) {
+    if (flag) return false;
+    flag = true;
+  }
+  if (!equalProp(a.kinds, b.kinds)) {
+    if (flag) return false;
+    flag = true;
+  }
+  if (!equalProp(a.limit, b.limit)) {
+    if (flag) return false;
+    flag = true;
+  }
+  if (!equalProp(a.until, b.until)) {
+    if (flag) return false;
+    flag = true;
+  }
+  if (!equalProp(a.since, b.since)) {
+    if (flag) return false;
+    flag = true;
+  }
+  if (!equalProp(a.search, b.search)) {
+    if (flag) return false;
+    flag = true;
+  }
+  if (!equalProp(a["#e"], b["#e"])) {
+    if (flag) return false;
+    flag = true;
+  }
+  if (!equalProp(a["#p"], b["#p"])) {
+    if (flag) return false;
+    flag = true;
+  }
+  if (!equalProp(a["#d"], b["#d"])) {
+    if (flag) return false;
+    flag = true;
+  }
+  if (!equalProp(a["#r"], b["#r"])) {
+    if (flag) return false;
+    flag = true;
+  }
+  if (!equalProp(a["#t"], b["#t"])) {
+    if (flag) return false;
+    flag = true;
+  }
+  return true;
+}
+
+function equalProp(a: string | number | Array<string | number> | undefined, b: string | number | Array<string | number> | undefined) {
+  if ((a !== undefined && b === undefined) || (a === undefined && b !== undefined)) {
+    return false;
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) {
+      return false;
+    }
+    if (!a.every(v => b.includes(v))) {
+      return false;
+    }
+  }
+  return a === b;
 }
 
 export function mergeSimilar(filters: Array<ReqFilter>): Array<ReqFilter> {

packages/system/src/RequestSplitter.ts

@@ -1,5 +1,5 @@
 import { ReqFilter } from ".";
-import { deepEqual } from "./Util";
+import { flatReqFilterEq } from "./Util";
 import { expandFilter } from "./RequestExpander";
 import { flatMerge } from "./RequestMerger";
 
@@ -7,8 +7,8 @@ export function diffFilters(prev: Array<ReqFilter>, next: Array<ReqFilter>) {
   const prevExpanded = prev.flatMap(expandFilter);
   const nextExpanded = next.flatMap(expandFilter);
 
-  const added = flatMerge(nextExpanded.filter(a => !prevExpanded.some(b => deepEqual(a, b))));
-  const removed = flatMerge(prevExpanded.filter(a => !nextExpanded.some(b => deepEqual(a, b))));
+  const added = flatMerge(nextExpanded.filter(a => !prevExpanded.some(b => flatReqFilterEq(a, b))));
+  const removed = flatMerge(prevExpanded.filter(a => !nextExpanded.some(b => flatReqFilterEq(a, b))));
 
   return {
     added,

packages/system/src/Util.ts

@@ -3,6 +3,7 @@ import * as secp from "@noble/curves/secp256k1";
 import { sha256 as sha2 } from "@noble/hashes/sha256";
 import { bech32 } from "bech32";
 import { NostrEvent, u256 } from "./Nostr";
+import { FlatReqFilter } from "RequestExpander";
 
 export function unwrap<T>(v: T | undefined | null): T {
   if (v === undefined || v === null) {
@@ -54,38 +55,19 @@ export function deepEqual(x: any, y: any): boolean {
     : x === y;
 }
 
-/**
- * Compute the "distance" between two objects by comparing their difference in properties
- * Missing/Added keys result in +10 distance
- * This is not recursive
- */
-export function distance(a: any, b: any): number {
-  const keys1 = Object.keys(a);
-  const keys2 = Object.keys(b);
-  const maxKeys = keys1.length > keys2.length ? keys1 : keys2;
-
-  let distance = 0;
-  for (const key of maxKeys) {
-    if (key in a && key in b) {
-      if (Array.isArray(a[key]) && Array.isArray(b[key])) {
-        const aa = a[key] as Array<string | number>;
-        const bb = b[key] as Array<string | number>;
-        if (aa.length === bb.length) {
-          if (aa.some(v => !bb.includes(v))) {
-            distance++;
-          }
-        } else {
-          distance++;
-        }
-      } else if (a[key] !== b[key]) {
-        distance++;
-      }
-    } else {
-      distance += 10;
-    }
-  }
-
-  return distance;
+export function flatReqFilterEq(a: FlatReqFilter, b: FlatReqFilter): boolean {
+  return a.ids === b.ids
+    && a.kinds === b.kinds
+    && a.authors === b.authors
+    && a.limit === b.limit
+    && a.since === b.since
+    && a.until === b.until
+    && a.search === b.search
+    && a["#e"] === b["#e"]
+    && a["#p"] === b["#p"]
+    && a["#t"] === b["#t"]
+    && a["#d"] === b["#d"]
+    && a["#r"] === b["#r"];
 }
 
 export function dedupe<T>(v: Array<T>) {