@diffson/core 1.0.0 → 1.0.1

package/src/service/comparator/array/AbstractArray.ts

@@ -1,34 +0,0 @@
-import { Inject } from "@wendellhu/redi";
-import type { IArrayComparator, IComparatorOrchestrator, JsonArray, JsonValue } from "../../../contract/type";
-import { IComparatorOrchestrator as IComparatorOrchestratorToken } from "../../../contract/type";
-import { DiffContext } from "../../diff/DiffContext";
-import type { PathTracker } from "../../diff/PathTracker";
-import { DIFFERENT } from "../../../contract/constant";
-
-export abstract class AbstractArray implements IArrayComparator {
-  constructor(
-    @Inject(IComparatorOrchestratorToken) protected orchestrator: IComparatorOrchestrator
-  ) {}
-
-  abstract diffArray(a: JsonArray, b: JsonArray, pathTracker: PathTracker): DiffContext;
-
-  diffElement(a: JsonValue | undefined, b: JsonValue | undefined, pathTracker: PathTracker): DiffContext {
-    return this.orchestrator.diffElement(a, b, pathTracker);
-  }
-
-  protected parentContextAddChildContext(parentResult: DiffContext, childResult: DiffContext): void {
-    if (childResult.isSame() === DIFFERENT) {
-      for (const singleNodeDifference of childResult.getDiffResultModels()) {
-        parentResult.getDiffResultModels().push(singleNodeDifference);
-      }
-      parentResult.setSame(false);
-    }
-  }
-
-  protected constructArrayPath(i: number): string {
-    if (i === null || i === undefined || i < 0) {
-      throw new Error("数组索引号入参为空或者为负。 入参:" + i);
-    }
-    return "[" + i + "]";
-  }
-}

package/src/service/comparator/array/SequentialArrayComparator.test.ts

@@ -1,46 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { DiffService } from "../../diff/DiffService";
-import { SequentialArrayComparator } from "./SequentialArrayComparator";
-
-function createSequentialDiffService(): DiffService {
-  return new DiffService().withArrayComparator(SequentialArrayComparator);
-}
-
-describe("SequentialArrayComparator", () => {
-  it("should compare arrays by index", () => {
-    const left = { items: [1, 2, 3] };
-    const right = { items: [1, 4, 3] };
-
-    const diffService = createSequentialDiffService();
-    const results = diffService.diffElement(left, right);
-
-    expect(results.length).toBe(1);
-    expect(results[0].leftPath).toBe("items.[1]");
-    expect(results[0].left).toBe("2");
-    expect(results[0].right).toBe("4");
-  });
-
-  it("should detect added elements", () => {
-    const left = { items: [1, 2] };
-    const right = { items: [1, 2, 3] };
-
-    const diffService = createSequentialDiffService();
-    const results = diffService.diffElement(left, right);
-
-    expect(results.length).toBe(1);
-    expect(results[0].diffType).toBe("ADD");
-    expect(results[0].rightPath).toBe("items.[2]");
-  });
-
-  it("should detect deleted elements", () => {
-    const left = { items: [1, 2, 3] };
-    const right = { items: [1, 2] };
-
-    const diffService = createSequentialDiffService();
-    const results = diffService.diffElement(left, right);
-
-    expect(results.length).toBe(1);
-    expect(results[0].diffType).toBe("DELETE");
-    expect(results[0].leftPath).toBe("items.[2]");
-  });
-});

package/src/service/comparator/array/SequentialArrayComparator.ts

@@ -1,48 +0,0 @@
-import { Inject } from "@wendellhu/redi";
-import { AbstractArray } from "./AbstractArray";
-import { DiffContext } from "../../diff/DiffContext";
-import type { PathTracker } from "../../diff/PathTracker";
-import type { JsonArray, IComparatorOrchestrator } from "../../../contract/type";
-import { IComparatorOrchestrator as IComparatorOrchestratorToken } from "../../../contract/type";
-
-export class SequentialArrayComparator extends AbstractArray {
-  constructor(
-    @Inject(IComparatorOrchestratorToken) orchestrator: IComparatorOrchestrator
-  ) {
-    super(orchestrator);
-  }
-
-  diffArray(a: JsonArray, b: JsonArray, pathTracker: PathTracker): DiffContext {
-    const arrayDiffContext = new DiffContext();
-    const maxLength = Math.max(a.length, b.length);
-
-    for (let i = 0; i < maxLength; i++) {
-      pathTracker.addAllpath(this.constructArrayPath(i));
-      const diffContext = this.generateDiffResult(a, b, i, pathTracker);
-      this.parentContextAddChildContext(arrayDiffContext, diffContext);
-      pathTracker.removeAllLastPath();
-    }
-    return arrayDiffContext;
-  }
-
-  private generateDiffResult(
-    a: JsonArray,
-    b: JsonArray,
-    i: number,
-    pathTracker: PathTracker
-  ): DiffContext {
-    if (i >= a.length && i >= b.length) {
-      throw new Error("数组索引号入参超过数组长度。 索引号:" + i + " 数组a:" + a + "数组b：" + b);
-    }
-
-    let diffContext: DiffContext;
-    if (i < a.length && i < b.length) {
-      diffContext = this.diffElement(a[i], b[i], pathTracker);
-    } else if (i >= a.length) {
-      diffContext = this.diffElement(undefined, b[i], pathTracker);
-    } else {
-      diffContext = this.diffElement(a[i], undefined, pathTracker);
-    }
-    return diffContext;
-  }
-}

package/src/service/comparator/array/SimilarArrayComparator.test.ts

@@ -1,37 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { DiffService } from "../../diff/DiffService";
-
-describe("SimilarArrayComparator", () => {
-  it("should match similar elements", () => {
-    const left = { items: [{ id: 1, name: "a" }, { id: 2, name: "b" }] };
-    const right = { items: [{ id: 2, name: "b" }, { id: 1, name: "a" }] };
-
-    const diffService = new DiffService();
-    const results = diffService.diffElement(left, right);
-
-    expect(results).toEqual([]);
-  });
-
-  it("should detect modifications in matched elements", () => {
-    const left = { items: [{ id: 1, name: "a" }] };
-    const right = { items: [{ id: 1, name: "b" }] };
-
-    const diffService = new DiffService();
-    const results = diffService.diffElement(left, right);
-
-    expect(results.length).toBe(1);
-    expect(results[0].left).toBe("a");
-    expect(results[0].right).toBe("b");
-  });
-
-  it("should detect added elements", () => {
-    const left = { items: [{ id: 1 }] };
-    const right = { items: [{ id: 1 }, { id: 2 }] };
-
-    const diffService = new DiffService();
-    const results = diffService.diffElement(left, right);
-
-    expect(results.length).toBe(1);
-    expect(results[0].diffType).toBe("ADD");
-  });
-});

package/src/service/comparator/array/SimilarArrayComparator.ts

@@ -1,211 +0,0 @@
-import { Inject } from "@wendellhu/redi";
-import { AbstractArray } from "./AbstractArray";
-import { DiffContext } from "../../diff/DiffContext";
-import type { PathTracker } from "../../diff/PathTracker";
-import type { JsonArray, IComparatorOrchestrator } from "../../../contract/type";
-import { SingleNodeDifference, IComparatorOrchestrator as IComparatorOrchestratorToken } from "../../../contract/type";
-
-export class SimilarArrayComparator extends AbstractArray {
-  private readonly USEABLE = false;
-  private readonly USED = true;
-
-  constructor(
-    @Inject(IComparatorOrchestratorToken) orchestrator: IComparatorOrchestrator
-  ) {
-    super(orchestrator);
-  }
-
-  diffArray(a: JsonArray, b: JsonArray, pathTracker: PathTracker): DiffContext {
-    let diffContext: DiffContext;
-
-    if (a.length <= b.length) {
-      diffContext = this.diff(a, b, pathTracker);
-    } else {
-      this.exchangeLeftAndRightPath(pathTracker);
-      diffContext = this.diff(b, a, pathTracker);
-      this.exchangeLeftAndRightPath(pathTracker);
-      this.exchangeResult(diffContext);
-    }
-    return diffContext;
-  }
-
-  private exchangeResult(diffContext: DiffContext): void {
-    const singleNodeDifferences = diffContext.getDiffResultModels();
-    for (const singleNodeDifference of singleNodeDifferences) {
-      this.exchangePathAndResult(singleNodeDifference);
-    }
-  }
-
-  private exchangePathAndResult(singleNodeDifference: SingleNodeDifference): void {
-    const tempStringA = singleNodeDifference.leftPath;
-    const tempLeft = singleNodeDifference.left;
-    singleNodeDifference.leftPath = singleNodeDifference.rightPath;
-    singleNodeDifference.rightPath = tempStringA;
-    singleNodeDifference.left = singleNodeDifference.right;
-    singleNodeDifference.right = tempLeft;
-  }
-
-  private exchangeLeftAndRightPath(pathTracker: PathTracker): void {
-    const tempA = pathTracker.getLeftPath();
-    pathTracker.setLeftPath(pathTracker.getRightPath());
-    pathTracker.setRightPath(tempA);
-  }
-
-  diff(a: JsonArray, b: JsonArray, pathTracker: PathTracker): DiffContext {
-    const rowlength = a.length;
-    const linelength = b.length;
-
-    const similarMatrix: number[][] = Array.from({ length: rowlength }, () =>
-      Array(linelength).fill(0)
-    );
-
-    const row: boolean[] = Array(rowlength).fill(false);
-    const line: boolean[] = Array(linelength).fill(false);
-
-    for (let i = 0; i < rowlength; i++) {
-      pathTracker.addLeftPath(this.constructArrayPath(i));
-      this.constructSimilarMatrix(a, b, i, pathTracker, similarMatrix, row, line);
-      pathTracker.removeLastLeftPath();
-    }
-    return this.obtainDiffResult(a, b, pathTracker, row, line, similarMatrix);
-  }
-
-  private obtainDiffResult(
-    a: JsonArray,
-    b: JsonArray,
-    pathTracker: PathTracker,
-    row: boolean[],
-    line: boolean[],
-    similarMatrix: number[][]
-  ): DiffContext {
-    const arrayDiffContext = new DiffContext();
-    this.obtainModifyDiffResult(a, b, pathTracker, row, line, similarMatrix, arrayDiffContext);
-    this.obtainAddDiffResult(b, pathTracker, line, arrayDiffContext);
-    return arrayDiffContext;
-  }
-
-  private obtainAddDiffResult(
-    b: JsonArray,
-    pathTracker: PathTracker,
-    line: boolean[],
-    arrayDiffContext: DiffContext
-  ): void {
-    for (let j = 0; j < line.length; j++) {
-      if (line[j] === this.USED) {
-        continue;
-      }
-      const addOrDeleteDiffContext = this.constructAddContext(b, j, pathTracker);
-      this.parentContextAddChildContext(arrayDiffContext, addOrDeleteDiffContext);
-    }
-  }
-
-  private obtainModifyDiffResult(
-    a: JsonArray,
-    b: JsonArray,
-    pathTracker: PathTracker,
-    row: boolean[],
-    line: boolean[],
-    similarMatrix: number[][],
-    arrayDiffContext: DiffContext
-  ): void {
-    let counts = 0;
-    for (const value of row) {
-      if (value === this.USEABLE) {
-        counts++;
-      }
-    }
-
-    for (let n = 0; n < counts; n++) {
-      let bestLineIndex = 0;
-      let bestRowIndex = 0;
-      let minDiffPair = Number.MAX_SAFE_INTEGER;
-
-      for (let i = 0; i < row.length; i++) {
-        for (let j = 0; j < line.length; j++) {
-          if (row[i] === this.USED || line[j] === this.USED) {
-            continue;
-          }
-          if (similarMatrix[i][j] < minDiffPair) {
-            bestRowIndex = i;
-            bestLineIndex = j;
-            minDiffPair = similarMatrix[i][j];
-          }
-        }
-      }
-
-      const modifyDiffContext = this.constructModifyContext(
-        a,
-        b,
-        bestRowIndex,
-        bestLineIndex,
-        pathTracker
-      );
-      row[bestRowIndex] = this.USED;
-      line[bestLineIndex] = this.USED;
-      this.parentContextAddChildContext(arrayDiffContext, modifyDiffContext);
-    }
-  }
-
-  private constructAddContext(
-    b: JsonArray,
-    index: number,
-    pathTracker: PathTracker
-  ): DiffContext {
-    pathTracker.addAllpath(this.constructArrayPath(index));
-    const diffContext = this.diffElement(undefined, b[index], pathTracker);
-    pathTracker.removeAllLastPath();
-    return diffContext;
-  }
-
-  private constructModifyContext(
-    a: JsonArray,
-    b: JsonArray,
-    i: number,
-    bestLineIndex: number,
-    pathTracker: PathTracker
-  ): DiffContext {
-    pathTracker.addLeftPath(this.constructArrayPath(i));
-    pathTracker.addRightPath(this.constructArrayPath(bestLineIndex));
-    const diffContext = this.diffElement(a[i], b[bestLineIndex], pathTracker);
-    pathTracker.removeAllLastPath();
-    return diffContext;
-  }
-
-  private constructSimilarMatrix(
-    arrayA: JsonArray,
-    arrayB: JsonArray,
-    rowIndex: number,
-    pathTracker: PathTracker,
-    similarArray: number[][],
-    row: boolean[],
-    line: boolean[]
-  ): void {
-    if (rowIndex < 0 || rowIndex >= arrayB.length) {
-      throw new Error(
-        "索引号入参超出数组长度。 索引号：" + rowIndex + " 数组B:" + JSON.stringify(arrayB)
-      );
-    }
-
-    for (let j = 0; j < arrayB.length; j++) {
-      if (line[j] === this.USEABLE) {
-        pathTracker.addRightPath(this.constructArrayPath(j));
-        const diffContext = this.diffElement(arrayA[rowIndex], arrayB[j], pathTracker);
-        pathTracker.removeLastRightPath();
-
-        if (diffContext.isSame()) {
-          row[rowIndex] = this.USED;
-          line[j] = this.USED;
-          return;
-        } else if (this.existSpecialPath(diffContext.getSpecialPathResult())) {
-          similarArray[rowIndex][j] = 0;
-        } else {
-          similarArray[rowIndex][j] = diffContext.getDiffResultModels().length;
-        }
-      }
-    }
-  }
-
-  private existSpecialPath(specialPathResult: string[] | null): boolean {
-    return specialPathResult !== null && specialPathResult.length > 0;
-  }
-}

package/src/service/comparator/array/index.ts

@@ -1,3 +0,0 @@
-export * from "./AbstractArray";
-export * from "./SequentialArrayComparator";
-export * from "./SimilarArrayComparator";

package/src/service/comparator/index.ts

@@ -1,6 +0,0 @@
-export * from "./ComparatorOrchestrator";
-export * from "./array";
-export * from "./object";
-export * from "./primitive";
-export * from "./nulls";
-export * from "./other";

package/src/service/comparator/nulls/DefaultNullComparator.test.ts

@@ -1,38 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { DiffService } from "../../diff/DiffService";
-
-describe("DefaultNullComparator", () => {
-  it("should not report differences for null vs null", () => {
-    const left = { value: null };
-    const right = { value: null };
-
-    const diffService = new DiffService();
-    const results = diffService.diffElement(left, right);
-
-    expect(results).toEqual([]);
-  });
-
-  it("should detect null to value changes", () => {
-    const left = { value: null };
-    const right = { value: 1 };
-
-    const diffService = new DiffService();
-    const results = diffService.diffElement(left, right);
-
-    expect(results.length).toBe(1);
-    expect(results[0].left).toBe("null");
-    expect(results[0].right).toBe("1");
-  });
-
-  it("should detect value to null changes", () => {
-    const left = { value: 1 };
-    const right = { value: null };
-
-    const diffService = new DiffService();
-    const results = diffService.diffElement(left, right);
-
-    expect(results.length).toBe(1);
-    expect(results[0].left).toBe("1");
-    expect(results[0].right).toBe("null");
-  });
-});

package/src/service/comparator/nulls/DefaultNullComparator.ts

@@ -1,9 +0,0 @@
-import type { INullComparator } from "../../../contract/type";
-import { DiffContext } from "../../diff/DiffContext";
-import type { PathTracker } from "../../diff/PathTracker";
-
-export class DefaultNullComparator implements INullComparator {
-  diff(_a: null, _b: null, _pathTracker: PathTracker): DiffContext {
-    return new DiffContext();
-  }
-}

package/src/service/comparator/nulls/index.ts

@@ -1 +0,0 @@
-export * from "./DefaultNullComparator";

package/src/service/comparator/object/AbstractObject.ts

@@ -1,102 +0,0 @@
-import { Inject } from "@wendellhu/redi";
-import type { IObjectComparator, IComparatorOrchestrator, JsonObject, JsonValue } from "../../../contract/type";
-import { IComparatorOrchestrator as IComparatorOrchestratorToken } from "../../../contract/type";
-import { DiffContext } from "../../diff/DiffContext";
-import type { PathTracker } from "../../diff/PathTracker";
-import { DIFFERENT, MERGE_PATH } from "../../../contract/constant";
-
-export abstract class AbstractObject implements IObjectComparator {
-  constructor(
-    @Inject(IComparatorOrchestratorToken) protected orchestrator: IComparatorOrchestrator
-  ) {}
-
-  abstract diff(a: JsonObject, b: JsonObject, pathTracker: PathTracker): DiffContext;
-
-  diffElement(a: JsonValue | undefined, b: JsonValue | undefined, pathTracker: PathTracker): DiffContext {
-    return this.orchestrator.diffElement(a, b, pathTracker);
-  }
-
-  protected parentContextAddChildContext(parentResult: DiffContext, childResult: DiffContext): void {
-    if (childResult.isSame() === DIFFERENT) {
-      for (const singleNodeDifference of childResult.getDiffResultModels()) {
-        parentResult.getDiffResultModels().push(singleNodeDifference);
-      }
-      parentResult.setSame(false);
-    }
-  }
-
-  protected diffValueByKey(
-    a: JsonObject,
-    b: JsonObject,
-    keySet: Set<string>,
-    pathTracker: PathTracker
-  ): DiffContext {
-    const objectDiffContext = new DiffContext();
-    const specialPathResult: string[] = [];
-
-    for (const key of keySet) {
-      pathTracker.addAllpath(key);
-
-      if (!this.needDiff(pathTracker.getNoisePahList(), pathTracker.getLeftPath())) {
-        pathTracker.removeAllLastPath();
-        continue;
-      }
-
-      const diffContext = this.diffElement(a[key], b[key], pathTracker);
-      this.parentContextAddChildContext(objectDiffContext, diffContext);
-
-      this.specialPathHandle(diffContext.isSame(), specialPathResult, pathTracker);
-      pathTracker.removeAllLastPath();
-    }
-    objectDiffContext.setSpecialPathResult(specialPathResult);
-    return objectDiffContext;
-  }
-
-  private specialPathHandle(
-    isSame: boolean,
-    specialPathResult: string[],
-    pathTracker: PathTracker
-  ): void {
-    if (!isSame) {
-      return;
-    }
-    const specialPath = this.getSpecialPath(pathTracker);
-    if (this.existPath(specialPath)) {
-      specialPathResult.push(specialPath!);
-    }
-  }
-
-  private existPath(specialPath: string | null): boolean {
-    return specialPath !== null;
-  }
-
-  protected getSpecialPath(pathTracker: PathTracker): string | null {
-    if (!pathTracker || !pathTracker.getSpecialPath() || pathTracker.getSpecialPath()!.length === 0) {
-      return null;
-    }
-    const currentPath = this.listJoin(pathTracker.getLeftPath());
-    if (pathTracker.getSpecialPath()!.includes(currentPath)) {
-      return currentPath;
-    }
-    return null;
-  }
-
-  protected needDiff(noisePahList: string[] | null, pathList: string[]): boolean {
-    if (!noisePahList || !pathList || noisePahList.length === 0 || pathList.length === 0) {
-      return true;
-    }
-    const path = this.listJoin(pathList);
-    if (noisePahList.includes(path)) {
-      return false;
-    }
-    return true;
-  }
-
-  protected listJoin(path: string[]): string {
-    if (!path) {
-      throw new Error("当前路径不能为空");
-    }
-    const filtered = path.filter((e) => e.charAt(0) !== "[");
-    return filtered.join(MERGE_PATH);
-  }
-}

package/src/service/comparator/object/LeftJoinObjectComparator.test.ts

@@ -1,71 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { Injector } from "@wendellhu/redi";
-import {
-  IComparatorOrchestrator,
-  IObjectComparator,
-  IArrayComparator,
-  IPrimitiveComparator,
-  INullComparator,
-  IOtherComparator,
-  IDiffService,
-} from "../../../contract/type";
-import { ComparatorOrchestrator } from "../ComparatorOrchestrator";
-import { LeftJoinObjectComparator } from "./LeftJoinObjectComparator";
-import { SimilarArrayComparator } from "../array/SimilarArrayComparator";
-import { DefaultPrimitiveComparator } from "../primitive/DefaultPrimitiveComparator";
-import { DefaultNullComparator } from "../nulls/DefaultNullComparator";
-import { DefaultOtherComparator } from "../other/DefaultOtherComparator";
-import { DiffService } from "../../diff/DiffService";
-
-function createLeftJoinDiffService(): IDiffService {
-  const injector = new Injector([
-    [IComparatorOrchestrator, { useClass: ComparatorOrchestrator, lazy: true }],
-    [IObjectComparator, { useClass: LeftJoinObjectComparator }],
-    [IArrayComparator, { useClass: SimilarArrayComparator }],
-    [IPrimitiveComparator, { useClass: DefaultPrimitiveComparator }],
-    [INullComparator, { useClass: DefaultNullComparator }],
-    [IOtherComparator, { useClass: DefaultOtherComparator }],
-    [IDiffService, { useClass: DiffService }],
-  ]);
-  return injector.get(IDiffService);
-}
-
-describe("LeftJoinObjectComparator", () => {
-  it("should only compare keys from left object", () => {
-    const left = { a: 1, b: 2 };
-    const right = { a: 1, b: 2, c: 3 };
-
-    const diffService = createLeftJoinDiffService();
-    const results = diffService.diffElement(left, right);
-
-    expect(results.length).toEqual(1);
-    expect(results[0].rightPath).toBe("c");
-    expect(results[0].diffType).toBe("ADD");
-  });
-
-  it("should detect changes in left keys", () => {
-    const left = { a: 1, b: 2 };
-    const right = { a: 2, b: 2, c: 3 };
-
-    const diffService = createLeftJoinDiffService();
-    const results = diffService.diffElement(left, right);
-
-    expect(results.length).toBe(2);
-    expect(results[0].leftPath).toBe("a");
-    expect(results[0].diffType).toBe("MODIFY");
-    expect(results[1].rightPath).toBe("c");
-    expect(results[1].diffType).toBe("ADD");
-  });
-
-  it("should detect missing keys in right object", () => {
-    const left = { a: 1, b: 2 };
-    const right = { a: 1 };
-
-    const diffService = createLeftJoinDiffService();
-    const results = diffService.diffElement(left, right);
-
-    expect(results.length).toBe(1);
-    expect(results[0].leftPath).toBe("b");
-    expect(results[0].diffType).toBe("DELETE");
-  });
-});

package/src/service/comparator/object/LeftJoinObjectComparator.ts

@@ -1,18 +0,0 @@
-import { Inject } from "@wendellhu/redi";
-import { AbstractObject } from "./AbstractObject";
-import { DiffContext } from "../../diff/DiffContext";
-import type { PathTracker } from "../../diff/PathTracker";
-import { type JsonObject, IComparatorOrchestrator } from "#contract";
-
-
-export class LeftJoinObjectComparator extends AbstractObject {
-  constructor(
-    @Inject(IComparatorOrchestrator) orchestrator: IComparatorOrchestrator
-  ) {
-    super(orchestrator);
-  }
-
-  diff(a: JsonObject, b: JsonObject, pathTracker: PathTracker): DiffContext {
-    return this.diffValueByKey(a, b, new Set(Object.keys(a)), pathTracker);
-  }
-}

package/src/service/comparator/object/UnionKeyObjectComparator.test.ts

@@ -1,20 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { DiffService } from "../../diff/DiffService";
-
-describe("UnionKeyObjectComparator", () => {
-  it("should compare all keys from both objects", () => {
-    const left = { a: 1, b: 2 };
-    const right = { b: 2, c: 3 };
-
-    const diffService = new DiffService();
-    const results = diffService.diffElement(left, right);
-
-    expect(results.length).toBe(2);
-
-    const deleteResult = results.find((r) => r.diffType === "DELETE");
-    const addResult = results.find((r) => r.diffType === "ADD");
-
-    expect(deleteResult?.leftPath).toBe("a");
-    expect(addResult?.rightPath).toBe("c");
-  });
-});

package/src/service/comparator/object/UnionKeyObjectComparator.ts

@@ -1,19 +0,0 @@
-import { Inject } from "@wendellhu/redi";
-import { AbstractObject } from "./AbstractObject";
-import { DiffContext } from "../../diff/DiffContext";
-import type { PathTracker } from "../../diff/PathTracker";
-import type { JsonObject, IComparatorOrchestrator } from "../../../contract/type";
-import { IComparatorOrchestrator as IComparatorOrchestratorToken } from "../../../contract/type";
-
-export class UnionKeyObjectComparator extends AbstractObject {
-  constructor(
-    @Inject(IComparatorOrchestratorToken) orchestrator: IComparatorOrchestrator
-  ) {
-    super(orchestrator);
-  }
-
-  diff(a: JsonObject, b: JsonObject, pathTracker: PathTracker): DiffContext {
-    const unionSet = new Set<string>([...Object.keys(a), ...Object.keys(b)]);
-    return this.diffValueByKey(a, b, unionSet, pathTracker);
-  }
-}

package/src/service/comparator/object/index.ts

@@ -1,3 +0,0 @@
-export * from "./AbstractObject";
-export * from "./UnionKeyObjectComparator";
-export * from "./LeftJoinObjectComparator";