refactor: simplify documents matching

Author: CountRedClaw

src/components/compare/compare.operations.ts

@@ -114,8 +114,8 @@ async function compareCurrentApiType(
   const { operations: prevOperations = [] } = await versionOperationsResolver(apiType, prev?.version ?? '', prev?.packageId ?? '', undefined, false) || {}
   const { operations: currOperations = [] } = await versionOperationsResolver(apiType, curr?.version ?? '', curr?.packageId ?? '', undefined, false) || {}
 
-  const [prevOperationIds, prevNormalizedOperationIdToOriginal] = normalizeOperationIds(prevOperations, apiBuilder)
-  const [currOperationIds, currNormalizedOperationIdToOriginal] = normalizeOperationIds(currOperations, apiBuilder)
+  const [prevOperationIds, prevNormalizedOperationIdToOperation] = normalizeOperationIds(prevOperations, apiBuilder)
+  const [currOperationIds, currNormalizedOperationIdToOperation] = normalizeOperationIds(currOperations, apiBuilder)
 
   const added = difference(currOperationIds, prevOperationIds)
   const removed = difference(prevOperationIds, currOperationIds)
@@ -130,39 +130,31 @@ async function compareCurrentApiType(
   // const currDocuments = ctx.config.files ? unfilteredCurrDocuments.filter(({fileId}) => ctx.config.files?.find((file) => file.fileId === fileId)) : unfilteredCurrDocuments
   const currDocuments = unfilteredCurrDocuments
 
-  const pairedRestDocs: Map<ResolvedVersionDocument, ResolvedVersionDocument> = new Map()
+  const pairedRestDocs: [ResolvedVersionDocument, ResolvedVersionDocument][] = []
   for (const normalizedOperationId of rest) {
-    const prevOperationId = prevNormalizedOperationIdToOriginal[normalizedOperationId]
-    const currOperationId = currNormalizedOperationIdToOriginal[normalizedOperationId]
-
-    const prevDocumentId = prevOperations.find((operation) => operation.operationId === prevOperationId)?.documentId
-    const currDocumentId = currOperations.find((operation) => operation.operationId === currOperationId)?.documentId
+    const prevDocumentId = prevNormalizedOperationIdToOperation[normalizedOperationId]?.documentId
+    const currDocumentId = currNormalizedOperationIdToOperation[normalizedOperationId]?.documentId
     const prevDoc = prevDocuments.find(document => document.slug === prevDocumentId)
     const currDoc = currDocuments.find(document => document.slug === currDocumentId)
 
     if (!prevDoc || !currDoc) {
       throw new Error('should not happen')
     }
 
-    if (pairedRestDocs.get(prevDoc) === currDoc) {
-      continue
-    }
-    pairedRestDocs.set(prevDoc, currDoc)
+    pairedRestDocs.push([prevDoc, currDoc])
   }
 
-  const pairedDocs: [ResolvedVersionDocument | undefined, ResolvedVersionDocument | undefined][] = [...pairedRestDocs.entries()]
-  const qwe = [...new Set(added.map((normalizedOperationId) => {
-    const operationId = currNormalizedOperationIdToOriginal[normalizedOperationId]
-    const currDocumentId = currOperations.find((operation) => operation.operationId === operationId)?.documentId
+  const pairedDocs: [ResolvedVersionDocument | undefined, ResolvedVersionDocument | undefined][] = dedupePairs(pairedRestDocs)
+  const uniqueCurrentDocuments = [...new Set(added.map((normalizedOperationId) => {
+    const currDocumentId = currNormalizedOperationIdToOperation[normalizedOperationId]?.documentId
     return currDocuments.find(document => document.slug === currDocumentId)
   }))]
-  for (const currDoc of qwe) {
+  for (const currDoc of uniqueCurrentDocuments) {
     pairedDocs.push([undefined, currDoc])
   }
 
   const asd = [...new Set(removed.map((normalizedOperationId) => {
-    const operationId = prevNormalizedOperationIdToOriginal[normalizedOperationId]
-    const prevDocumentId = prevOperations.find((operation) => operation.operationId === operationId)?.documentId
+    const prevDocumentId = prevNormalizedOperationIdToOperation[normalizedOperationId]?.documentId
     return prevDocuments.find(document => document.slug === prevDocumentId)
   }))]
   for (const prevDoc of asd) {

src/components/compare/compare.utils.ts

@@ -97,13 +97,33 @@ export function getOperationTypesFromTwoVersions(
 type OperationIdWithoutGroupPrefix = string
 export type OperationIdentityMap = Record<OperationIdWithoutGroupPrefix, OperationId>
 
-export function normalizeOperationIds(operations: ResolvedOperation[], apiBuilder: ApiBuilder): [OperationId[], Record<NormalizedOperationId | OperationId, OperationId>] {
-  const normalizedOperationIdToOriginal: Record<NormalizedOperationId | OperationId, OperationId> = {}
+export function dedupePairs<A extends object, B extends object>(
+  pairs: ReadonlyArray<[A, B]>,
+): Array<[A, B]> {
+  const seen = new WeakMap<A, WeakSet<B>>()
+  const out: Array<[A, B]> = []
+
+  for (const [a, b] of pairs) {
+    let bs = seen.get(a)
+    if (!bs) {
+      bs = new WeakSet<B>()
+      seen.set(a, bs)
+    }
+    if (bs.has(b)) continue
+    bs.add(b)
+    out.push([a, b])
+  }
+
+  return out
+}
+
+export function normalizeOperationIds(operations: ResolvedOperation[], apiBuilder: ApiBuilder): [OperationId[], Record<NormalizedOperationId | OperationId, ResolvedOperation>] {
+  const normalizedOperationIdToOperation: Record<NormalizedOperationId | OperationId, ResolvedOperation> = {}
   for (const operation of operations) {
     const normalizedOperationId = apiBuilder.createNormalizedOperationId?.(operation) ?? operation.operationId
-    normalizedOperationIdToOriginal[normalizedOperationId] = operation.operationId
+    normalizedOperationIdToOperation[normalizedOperationId] = operation
   }
-  return [Object.keys(normalizedOperationIdToOriginal), normalizedOperationIdToOriginal]
+  return [Object.keys(normalizedOperationIdToOperation), normalizedOperationIdToOperation]
 }
 
 export function getOperationsHashMapByApiType(