@diffson/core 1.0.0

package/dist/util/index.js

@@ -0,0 +1,2 @@
+export * from "./TypeGuards";
+//# sourceMappingURL=index.js.map

package/dist/util/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/util/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC"}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@diffson/core",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "imports": {
+    "#contract": "./src/contract/index.ts",
+    "#service": "./src/service/index.ts"
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "@diffson/source": "./src/index.ts",
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "@diffson/source": "./src/index.ts",
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist node_modules"
+  },
+  "dependencies": {
+    "@wendellhu/redi": "latest",
+    "is-json": "latest"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.7.0"
+  }
+}

package/src/contract/constant/DiffConstants.ts

@@ -0,0 +1,10 @@
+export const DIFFERENT = false;
+export const SAME = true;
+export const SPLIT_PATH = "\\.";
+export const MERGE_PATH = ".";
+
+export const OBJECT_NULL = null;
+export const TYPE_MODIFY = "MODIFY";
+export const TYPE_ADD = "ADD";
+export const TYPE_DELETE = "DELETE";
+

package/src/contract/constant/PresetName.ts

@@ -0,0 +1,6 @@
+export enum PresetName {
+  FullSmart = "fullSmart",
+  FullOrdered = "fullOrdered",
+  LeftSmart = "leftSmart",
+  LeftOrdered = "leftOrdered",
+}

package/src/contract/constant/index.ts

@@ -0,0 +1,2 @@
+export * from "./DiffConstants";
+export * from "./PresetName";

package/src/contract/index.ts

@@ -0,0 +1,2 @@
+export * from "./type";
+export * from "./constant";

package/src/contract/type/ArrayComparator.ts

@@ -0,0 +1,15 @@
+import { createIdentifier } from "@wendellhu/redi";
+import type { JsonArray, JsonValue } from "./JsonTypes";
+import type { DiffContext } from "../../service/diff/DiffContext";
+import type { PathTracker } from "../../service/diff/PathTracker";
+
+export interface IArrayComparator {
+  diffArray(a: JsonArray, b: JsonArray, pathTracker: PathTracker): DiffContext;
+  diffElement(
+    a: JsonValue | undefined,
+    b: JsonValue | undefined,
+    pathTracker: PathTracker
+  ): DiffContext;
+}
+
+export const IArrayComparator = createIdentifier<IArrayComparator>("IArrayComparator");

package/src/contract/type/ComparatorOrchestrator.ts

@@ -0,0 +1,16 @@
+import { createIdentifier } from "@wendellhu/redi";
+import type { JsonValue } from "./JsonTypes";
+import type { DiffContext } from "../../service/diff/DiffContext";
+import type { PathTracker } from "../../service/diff/PathTracker";
+import type { IArrayComparator } from "./ArrayComparator";
+
+export interface IComparatorOrchestrator {
+  diffElement(
+    a: JsonValue | undefined,
+    b: JsonValue | undefined,
+    pathTracker: PathTracker
+  ): DiffContext;
+  getArrayComparator(): IArrayComparator;
+}
+
+export const IComparatorOrchestrator = createIdentifier<IComparatorOrchestrator>("IComparatorOrchestrator");

package/src/contract/type/DiffService.ts

@@ -0,0 +1,31 @@
+import { createIdentifier } from "@wendellhu/redi";
+import type { JsonValue } from "./JsonTypes";
+import type { Result } from "./Result";
+
+export interface IDiffService {
+  /**
+   * Diff two JSON strings
+   * @param leftJson - Left JSON string
+   * @param rightJson - Right JSON string
+   * @returns Array of differences
+   */
+  diffJson(leftJson: string, rightJson: string, options?: {
+    noisePath?: string[];
+    specialPath?: string[];
+    parseNestedJson?: boolean;
+  }): Result[];
+
+  /**
+   * Diff two JSON objects directly
+   * @param left - Left JSON value
+   * @param right - Right JSON value
+   * @returns Array of differences
+   */
+  diffElement(left: JsonValue, right: JsonValue, options?: {
+    noisePath?: string[];
+    specialPath?: string[];
+    parseNestedJson?: boolean;
+  }): Result[];
+}
+
+export const IDiffService = createIdentifier<IDiffService>("IDiffService");

package/src/contract/type/JsonTypes.ts

@@ -0,0 +1,3 @@
+export type JsonValue = string | number | boolean | null | JsonObject | JsonArray;
+export type JsonObject = { [key: string]: JsonValue };
+export type JsonArray = JsonValue[];

package/src/contract/type/NullComparator.ts

@@ -0,0 +1,9 @@
+import { createIdentifier } from "@wendellhu/redi";
+import type { DiffContext } from "../../service/diff/DiffContext";
+import type { PathTracker } from "../../service/diff/PathTracker";
+
+export interface INullComparator {
+  diff(a: null, b: null, pathTracker: PathTracker): DiffContext;
+}
+
+export const INullComparator = createIdentifier<INullComparator>("INullComparator");

package/src/contract/type/ObjectComparator.ts

@@ -0,0 +1,15 @@
+import { createIdentifier } from "@wendellhu/redi";
+import type { JsonObject, JsonValue } from "./JsonTypes";
+import type { DiffContext } from "../../service/diff/DiffContext";
+import type { PathTracker } from "../../service/diff/PathTracker";
+
+export interface IObjectComparator {
+  diff(a: JsonObject, b: JsonObject, pathTracker: PathTracker): DiffContext;
+  diffElement(
+    a: JsonValue | undefined,
+    b: JsonValue | undefined,
+    pathTracker: PathTracker
+  ): DiffContext;
+}
+
+export const IObjectComparator = createIdentifier<IObjectComparator>("IObjectComparator");

package/src/contract/type/OtherComparator.ts

@@ -0,0 +1,14 @@
+import { createIdentifier } from "@wendellhu/redi";
+import type { JsonValue } from "./JsonTypes";
+import type { DiffContext } from "../../service/diff/DiffContext";
+import type { PathTracker } from "../../service/diff/PathTracker";
+
+export interface IOtherComparator {
+  diff(
+    a: JsonValue | undefined,
+    b: JsonValue | undefined,
+    pathTracker: PathTracker
+  ): DiffContext;
+}
+
+export const IOtherComparator = createIdentifier<IOtherComparator>("IOtherComparator");

package/src/contract/type/PrimitiveComparator.ts

@@ -0,0 +1,13 @@
+import { createIdentifier } from "@wendellhu/redi";
+import type { DiffContext } from "../../service/diff/DiffContext";
+import type { PathTracker } from "../../service/diff/PathTracker";
+
+export interface IPrimitiveComparator {
+  diff(
+    a: string | number | boolean,
+    b: string | number | boolean,
+    pathTracker: PathTracker
+  ): DiffContext;
+}
+
+export const IPrimitiveComparator = createIdentifier<IPrimitiveComparator>("IPrimitiveComparator");

package/src/contract/type/Result.ts

@@ -0,0 +1,7 @@
+export class Result {
+  leftPath: string | null = null;
+  rightPath: string | null = null;
+  left: unknown = null;
+  right: unknown = null;
+  diffType: string = "";
+}

package/src/contract/type/SingleNodeDifference.ts

@@ -0,0 +1,13 @@
+export class SingleNodeDifference {
+  leftPath: string;
+  rightPath: string;
+  left: unknown;
+  right: unknown;
+
+  constructor(leftPath: string, rightPath: string, left: unknown, right: unknown) {
+    this.leftPath = leftPath;
+    this.rightPath = rightPath;
+    this.left = left;
+    this.right = right;
+  }
+}

package/src/contract/type/index.ts

@@ -0,0 +1,10 @@
+export * from "./JsonTypes";
+export * from "./Result";
+export * from "./SingleNodeDifference";
+export * from "./ComparatorOrchestrator";
+export * from "./ObjectComparator";
+export * from "./ArrayComparator";
+export * from "./PrimitiveComparator";
+export * from "./NullComparator";
+export * from "./OtherComparator";
+export * from "./DiffService";

package/src/index.ts

@@ -0,0 +1,17 @@
+// Public API - Types
+export type { JsonValue, JsonObject, JsonArray } from "./contract/type/JsonTypes";
+export { Result } from "./contract/type/Result";
+export * from "./contract/type/DiffService";
+
+// Public API - Constants
+export {
+  TYPE_ADD,
+  TYPE_DELETE,
+  TYPE_MODIFY,
+} from "./contract/constant";
+
+// Public API - Enums
+export { PresetName } from "./contract/constant/PresetName";
+
+// Public API - Service
+export { DiffService } from "./service";

package/src/service/comparator/ComparatorOrchestrator.ts

@@ -0,0 +1,50 @@
+import { Inject } from "@wendellhu/redi";
+import {
+  type IComparatorOrchestrator,
+  type IObjectComparator,
+  IObjectComparator as IObjectComparatorToken,
+  type IArrayComparator,
+  IArrayComparator as IArrayComparatorToken,
+  type IPrimitiveComparator,
+  IPrimitiveComparator as IPrimitiveComparatorToken,
+  type INullComparator,
+  INullComparator as INullComparatorToken,
+  type IOtherComparator,
+  IOtherComparator as IOtherComparatorToken,
+  type JsonValue,
+} from "../../contract/type";
+import { DiffContext } from "../diff/DiffContext";
+import type { PathTracker } from "../diff/PathTracker";
+import { isJsonObject, isJsonArray, isJsonPrimitive, isJsonNull } from "../../util";
+
+export class ComparatorOrchestrator implements IComparatorOrchestrator {
+  constructor(
+    @Inject(IObjectComparatorToken) protected objectComparator: IObjectComparator,
+    @Inject(IArrayComparatorToken) protected arrayComparator: IArrayComparator,
+    @Inject(IPrimitiveComparatorToken) protected primitiveComparator: IPrimitiveComparator,
+    @Inject(INullComparatorToken) protected nullComparator: INullComparator,
+    @Inject(IOtherComparatorToken) protected otherComparator: IOtherComparator
+  ) {}
+
+  diffElement(
+    a: JsonValue | undefined,
+    b: JsonValue | undefined,
+    pathTracker: PathTracker
+  ): DiffContext {
+    if (isJsonObject(a) && isJsonObject(b)) {
+      return this.objectComparator.diff(a, b, pathTracker);
+    } else if (isJsonArray(a) && isJsonArray(b)) {
+      return this.arrayComparator.diffArray(a, b, pathTracker);
+    } else if (isJsonPrimitive(a) && isJsonPrimitive(b)) {
+      return this.primitiveComparator.diff(a, b, pathTracker);
+    } else if (isJsonNull(a) && isJsonNull(b)) {
+      return this.nullComparator.diff(a, b, pathTracker);
+    } else {
+      return this.otherComparator.diff(a, b, pathTracker);
+    }
+  }
+
+  getArrayComparator(): IArrayComparator {
+    return this.arrayComparator;
+  }
+}

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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,37 @@
+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");
+  });
+});