@diffson/core 1.0.3 → 1.0.5

package/dist/contract/constant/DiffConstants.d.ts

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

package/dist/contract/constant/DiffConstants.js

@@ -0,0 +1,8 @@
+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/dist/contract/constant/PresetName.d.ts

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

package/dist/contract/constant/PresetName.js

@@ -0,0 +1,7 @@
+export var PresetName;
+(function (PresetName) {
+    PresetName["FullSmart"] = "fullSmart";
+    PresetName["FullOrdered"] = "fullOrdered";
+    PresetName["LeftSmart"] = "leftSmart";
+    PresetName["LeftOrdered"] = "leftOrdered";
+})(PresetName || (PresetName = {}));

package/dist/contract/constant/index.d.ts

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

package/dist/contract/constant/index.js

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

package/dist/contract/index.d.ts

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

package/dist/contract/index.js

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

package/dist/contract/type/ArrayComparator.d.ts

@@ -0,0 +1,8 @@
+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 declare const IArrayComparator: import("@wendellhu/redi").IdentifierDecorator<IArrayComparator>;

package/dist/contract/type/ArrayComparator.js

@@ -0,0 +1,2 @@
+import { createIdentifier } from "@wendellhu/redi";
+export const IArrayComparator = createIdentifier("IArrayComparator");

package/dist/contract/type/ComparatorOrchestrator.d.ts

@@ -0,0 +1,9 @@
+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 declare const IComparatorOrchestrator: import("@wendellhu/redi").IdentifierDecorator<IComparatorOrchestrator>;

package/dist/contract/type/ComparatorOrchestrator.js

@@ -0,0 +1,2 @@
+import { createIdentifier } from "@wendellhu/redi";
+export const IComparatorOrchestrator = createIdentifier("IComparatorOrchestrator");

package/dist/contract/type/DiffService.d.ts

@@ -0,0 +1,27 @@
+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 declare const IDiffService: import("@wendellhu/redi").IdentifierDecorator<IDiffService>;

package/dist/contract/type/DiffService.js

@@ -0,0 +1,2 @@
+import { createIdentifier } from "@wendellhu/redi";
+export const IDiffService = createIdentifier("IDiffService");

package/dist/contract/type/JsonTypes.d.ts

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

package/dist/contract/type/JsonTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/contract/type/NullComparator.d.ts

@@ -0,0 +1,6 @@
+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 declare const INullComparator: import("@wendellhu/redi").IdentifierDecorator<INullComparator>;

package/dist/contract/type/NullComparator.js

@@ -0,0 +1,2 @@
+import { createIdentifier } from "@wendellhu/redi";
+export const INullComparator = createIdentifier("INullComparator");

package/dist/contract/type/ObjectComparator.d.ts

@@ -0,0 +1,8 @@
+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 declare const IObjectComparator: import("@wendellhu/redi").IdentifierDecorator<IObjectComparator>;

package/dist/contract/type/ObjectComparator.js

@@ -0,0 +1,2 @@
+import { createIdentifier } from "@wendellhu/redi";
+export const IObjectComparator = createIdentifier("IObjectComparator");

package/dist/contract/type/OtherComparator.d.ts

@@ -0,0 +1,7 @@
+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 declare const IOtherComparator: import("@wendellhu/redi").IdentifierDecorator<IOtherComparator>;

package/dist/contract/type/OtherComparator.js

@@ -0,0 +1,2 @@
+import { createIdentifier } from "@wendellhu/redi";
+export const IOtherComparator = createIdentifier("IOtherComparator");

package/dist/contract/type/PrimitiveComparator.d.ts

@@ -0,0 +1,6 @@
+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 declare const IPrimitiveComparator: import("@wendellhu/redi").IdentifierDecorator<IPrimitiveComparator>;

package/dist/contract/type/PrimitiveComparator.js

@@ -0,0 +1,2 @@
+import { createIdentifier } from "@wendellhu/redi";
+export const IPrimitiveComparator = createIdentifier("IPrimitiveComparator");

package/dist/contract/type/Result.d.ts

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

package/dist/contract/type/Result.js

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

package/dist/contract/type/SingleNodeDifference.d.ts

@@ -0,0 +1,7 @@
+export declare class SingleNodeDifference {
+    leftPath: string;
+    rightPath: string;
+    left: unknown;
+    right: unknown;
+    constructor(leftPath: string, rightPath: string, left: unknown, right: unknown);
+}

package/dist/contract/type/SingleNodeDifference.js

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

package/dist/contract/type/index.d.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/dist/contract/type/index.js

@@ -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/dist/index.d.ts

@@ -0,0 +1,6 @@
+export type { JsonValue, JsonObject, JsonArray } from "./contract/type/JsonTypes";
+export { Result } from "./contract/type/Result";
+export * from "./contract/type/DiffService";
+export { TYPE_ADD, TYPE_DELETE, TYPE_MODIFY, } from "./contract/constant";
+export { PresetName } from "./contract/constant/PresetName";
+export { DiffService } from "./service";

package/dist/index.js

@@ -0,0 +1,8 @@
+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/dist/service/comparator/ComparatorOrchestrator.d.ts

@@ -0,0 +1,13 @@
+import { type IComparatorOrchestrator, type IObjectComparator, type IArrayComparator, type IPrimitiveComparator, type INullComparator, type IOtherComparator, type JsonValue } from "../../contract/type";
+import { DiffContext } from "../diff/DiffContext";
+import type { PathTracker } from "../diff/PathTracker";
+export declare class ComparatorOrchestrator implements IComparatorOrchestrator {
+    protected objectComparator: IObjectComparator;
+    protected arrayComparator: IArrayComparator;
+    protected primitiveComparator: IPrimitiveComparator;
+    protected nullComparator: INullComparator;
+    protected otherComparator: IOtherComparator;
+    constructor(objectComparator: IObjectComparator, arrayComparator: IArrayComparator, primitiveComparator: IPrimitiveComparator, nullComparator: INullComparator, otherComparator: IOtherComparator);
+    diffElement(a: JsonValue | undefined, b: JsonValue | undefined, pathTracker: PathTracker): DiffContext;
+    getArrayComparator(): IArrayComparator;
+}

package/dist/service/comparator/ComparatorOrchestrator.js

@@ -0,0 +1,55 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Inject } from "@wendellhu/redi";
+import { IObjectComparator as IObjectComparatorToken, IArrayComparator as IArrayComparatorToken, IPrimitiveComparator as IPrimitiveComparatorToken, INullComparator as INullComparatorToken, IOtherComparator as IOtherComparatorToken, } from "../../contract/type";
+import { DiffContext } from "../diff/DiffContext";
+import { isJsonObject, isJsonArray, isJsonPrimitive, isJsonNull } from "../../util";
+let ComparatorOrchestrator = class ComparatorOrchestrator {
+    objectComparator;
+    arrayComparator;
+    primitiveComparator;
+    nullComparator;
+    otherComparator;
+    constructor(objectComparator, arrayComparator, primitiveComparator, nullComparator, otherComparator) {
+        this.objectComparator = objectComparator;
+        this.arrayComparator = arrayComparator;
+        this.primitiveComparator = primitiveComparator;
+        this.nullComparator = nullComparator;
+        this.otherComparator = otherComparator;
+    }
+    diffElement(a, b, pathTracker) {
+        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() {
+        return this.arrayComparator;
+    }
+};
+ComparatorOrchestrator = __decorate([
+    __param(0, Inject(IObjectComparatorToken)),
+    __param(1, Inject(IArrayComparatorToken)),
+    __param(2, Inject(IPrimitiveComparatorToken)),
+    __param(3, Inject(INullComparatorToken)),
+    __param(4, Inject(IOtherComparatorToken))
+], ComparatorOrchestrator);
+export { ComparatorOrchestrator };

package/dist/service/comparator/array/AbstractArray.d.ts

@@ -0,0 +1,11 @@
+import type { IArrayComparator, IComparatorOrchestrator, JsonArray, JsonValue } from "../../../contract/type";
+import { DiffContext } from "../../diff/DiffContext";
+import type { PathTracker } from "../../diff/PathTracker";
+export declare abstract class AbstractArray implements IArrayComparator {
+    protected orchestrator: IComparatorOrchestrator;
+    constructor(orchestrator: IComparatorOrchestrator);
+    abstract diffArray(a: JsonArray, b: JsonArray, pathTracker: PathTracker): DiffContext;
+    diffElement(a: JsonValue | undefined, b: JsonValue | undefined, pathTracker: PathTracker): DiffContext;
+    protected parentContextAddChildContext(parentResult: DiffContext, childResult: DiffContext): void;
+    protected constructArrayPath(i: number): string;
+}

package/dist/service/comparator/array/AbstractArray.js

@@ -0,0 +1,40 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Inject } from "@wendellhu/redi";
+import { IComparatorOrchestrator as IComparatorOrchestratorToken } from "../../../contract/type";
+import { DiffContext } from "../../diff/DiffContext";
+import { DIFFERENT } from "../../../contract/constant";
+let AbstractArray = class AbstractArray {
+    orchestrator;
+    constructor(orchestrator) {
+        this.orchestrator = orchestrator;
+    }
+    diffElement(a, b, pathTracker) {
+        return this.orchestrator.diffElement(a, b, pathTracker);
+    }
+    parentContextAddChildContext(parentResult, childResult) {
+        if (childResult.isSame() === DIFFERENT) {
+            for (const singleNodeDifference of childResult.getDiffResultModels()) {
+                parentResult.getDiffResultModels().push(singleNodeDifference);
+            }
+            parentResult.setSame(false);
+        }
+    }
+    constructArrayPath(i) {
+        if (i === null || i === undefined || i < 0) {
+            throw new Error("数组索引号入参为空或者为负。 入参:" + i);
+        }
+        return "[" + i + "]";
+    }
+};
+AbstractArray = __decorate([
+    __param(0, Inject(IComparatorOrchestratorToken))
+], AbstractArray);
+export { AbstractArray };

package/dist/service/comparator/array/SequentialArrayComparator.d.ts

@@ -0,0 +1,9 @@
+import { AbstractArray } from "./AbstractArray";
+import { DiffContext } from "../../diff/DiffContext";
+import type { PathTracker } from "../../diff/PathTracker";
+import type { JsonArray, IComparatorOrchestrator } from "../../../contract/type";
+export declare class SequentialArrayComparator extends AbstractArray {
+    constructor(orchestrator: IComparatorOrchestrator);
+    diffArray(a: JsonArray, b: JsonArray, pathTracker: PathTracker): DiffContext;
+    private generateDiffResult;
+}

package/dist/service/comparator/array/SequentialArrayComparator.js

@@ -0,0 +1,49 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Inject } from "@wendellhu/redi";
+import { AbstractArray } from "./AbstractArray";
+import { DiffContext } from "../../diff/DiffContext";
+import { IComparatorOrchestrator as IComparatorOrchestratorToken } from "../../../contract/type";
+let SequentialArrayComparator = class SequentialArrayComparator extends AbstractArray {
+    constructor(orchestrator) {
+        super(orchestrator);
+    }
+    diffArray(a, b, pathTracker) {
+        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;
+    }
+    generateDiffResult(a, b, i, pathTracker) {
+        if (i >= a.length && i >= b.length) {
+            throw new Error("数组索引号入参超过数组长度。 索引号:" + i + " 数组a:" + a + "数组b：" + b);
+        }
+        let 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;
+    }
+};
+SequentialArrayComparator = __decorate([
+    __param(0, Inject(IComparatorOrchestratorToken))
+], SequentialArrayComparator);
+export { SequentialArrayComparator };

package/dist/service/comparator/array/SimilarArrayComparator.d.ts

@@ -0,0 +1,21 @@
+import { AbstractArray } from "./AbstractArray";
+import { DiffContext } from "../../diff/DiffContext";
+import type { PathTracker } from "../../diff/PathTracker";
+import type { JsonArray, IComparatorOrchestrator } from "../../../contract/type";
+export declare class SimilarArrayComparator extends AbstractArray {
+    private readonly USEABLE;
+    private readonly USED;
+    constructor(orchestrator: IComparatorOrchestrator);
+    diffArray(a: JsonArray, b: JsonArray, pathTracker: PathTracker): DiffContext;
+    private exchangeResult;
+    private exchangePathAndResult;
+    private exchangeLeftAndRightPath;
+    diff(a: JsonArray, b: JsonArray, pathTracker: PathTracker): DiffContext;
+    private obtainDiffResult;
+    private obtainAddDiffResult;
+    private obtainModifyDiffResult;
+    private constructAddContext;
+    private constructModifyContext;
+    private constructSimilarMatrix;
+    private existSpecialPath;
+}

package/dist/service/comparator/array/SimilarArrayComparator.js

@@ -0,0 +1,152 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Inject } from "@wendellhu/redi";
+import { AbstractArray } from "./AbstractArray";
+import { DiffContext } from "../../diff/DiffContext";
+import { SingleNodeDifference, IComparatorOrchestrator as IComparatorOrchestratorToken } from "../../../contract/type";
+let SimilarArrayComparator = class SimilarArrayComparator extends AbstractArray {
+    USEABLE = false;
+    USED = true;
+    constructor(orchestrator) {
+        super(orchestrator);
+    }
+    diffArray(a, b, pathTracker) {
+        let 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;
+    }
+    exchangeResult(diffContext) {
+        const singleNodeDifferences = diffContext.getDiffResultModels();
+        for (const singleNodeDifference of singleNodeDifferences) {
+            this.exchangePathAndResult(singleNodeDifference);
+        }
+    }
+    exchangePathAndResult(singleNodeDifference) {
+        const tempStringA = singleNodeDifference.leftPath;
+        const tempLeft = singleNodeDifference.left;
+        singleNodeDifference.leftPath = singleNodeDifference.rightPath;
+        singleNodeDifference.rightPath = tempStringA;
+        singleNodeDifference.left = singleNodeDifference.right;
+        singleNodeDifference.right = tempLeft;
+    }
+    exchangeLeftAndRightPath(pathTracker) {
+        const tempA = pathTracker.getLeftPath();
+        pathTracker.setLeftPath(pathTracker.getRightPath());
+        pathTracker.setRightPath(tempA);
+    }
+    diff(a, b, pathTracker) {
+        const rowlength = a.length;
+        const linelength = b.length;
+        const similarMatrix = Array.from({ length: rowlength }, () => Array(linelength).fill(0));
+        const row = Array(rowlength).fill(false);
+        const line = 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);
+    }
+    obtainDiffResult(a, b, pathTracker, row, line, similarMatrix) {
+        const arrayDiffContext = new DiffContext();
+        this.obtainModifyDiffResult(a, b, pathTracker, row, line, similarMatrix, arrayDiffContext);
+        this.obtainAddDiffResult(b, pathTracker, line, arrayDiffContext);
+        return arrayDiffContext;
+    }
+    obtainAddDiffResult(b, pathTracker, line, arrayDiffContext) {
+        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);
+        }
+    }
+    obtainModifyDiffResult(a, b, pathTracker, row, line, similarMatrix, arrayDiffContext) {
+        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);
+        }
+    }
+    constructAddContext(b, index, pathTracker) {
+        pathTracker.addAllpath(this.constructArrayPath(index));
+        const diffContext = this.diffElement(undefined, b[index], pathTracker);
+        pathTracker.removeAllLastPath();
+        return diffContext;
+    }
+    constructModifyContext(a, b, i, bestLineIndex, pathTracker) {
+        pathTracker.addLeftPath(this.constructArrayPath(i));
+        pathTracker.addRightPath(this.constructArrayPath(bestLineIndex));
+        const diffContext = this.diffElement(a[i], b[bestLineIndex], pathTracker);
+        pathTracker.removeAllLastPath();
+        return diffContext;
+    }
+    constructSimilarMatrix(arrayA, arrayB, rowIndex, pathTracker, similarArray, row, line) {
+        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;
+                }
+            }
+        }
+    }
+    existSpecialPath(specialPathResult) {
+        return specialPathResult !== null && specialPathResult.length > 0;
+    }
+};
+SimilarArrayComparator = __decorate([
+    __param(0, Inject(IComparatorOrchestratorToken))
+], SimilarArrayComparator);
+export { SimilarArrayComparator };

package/dist/service/comparator/array/index.d.ts

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

package/dist/service/comparator/array/index.js

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

package/dist/service/comparator/index.d.ts

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