@diffson/core 1.0.3 → 1.0.5

package/dist/service/comparator/index.js

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

package/dist/service/comparator/nulls/DefaultNullComparator.d.ts

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

package/dist/service/comparator/nulls/DefaultNullComparator.js

@@ -0,0 +1,6 @@
+import { DiffContext } from "../../diff/DiffContext";
+export class DefaultNullComparator {
+    diff(_a, _b, _pathTracker) {
+        return new DiffContext();
+    }
+}

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

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

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

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

package/dist/service/comparator/object/AbstractObject.d.ts

@@ -0,0 +1,16 @@
+import type { IObjectComparator, IComparatorOrchestrator, JsonObject, JsonValue } from "../../../contract/type";
+import { DiffContext } from "../../diff/DiffContext";
+import type { PathTracker } from "../../diff/PathTracker";
+export declare abstract class AbstractObject implements IObjectComparator {
+    protected orchestrator: IComparatorOrchestrator;
+    constructor(orchestrator: IComparatorOrchestrator);
+    abstract diff(a: JsonObject, b: JsonObject, pathTracker: PathTracker): DiffContext;
+    diffElement(a: JsonValue | undefined, b: JsonValue | undefined, pathTracker: PathTracker): DiffContext;
+    protected parentContextAddChildContext(parentResult: DiffContext, childResult: DiffContext): void;
+    protected diffValueByKey(a: JsonObject, b: JsonObject, keySet: Set<string>, pathTracker: PathTracker): DiffContext;
+    private specialPathHandle;
+    private existPath;
+    protected getSpecialPath(pathTracker: PathTracker): string | null;
+    protected needDiff(noisePahList: string[] | null, pathList: string[]): boolean;
+    protected listJoin(path: string[]): string;
+}

package/dist/service/comparator/object/AbstractObject.js

@@ -0,0 +1,90 @@
+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, MERGE_PATH } from "../../../contract/constant";
+let AbstractObject = class AbstractObject {
+    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);
+        }
+    }
+    diffValueByKey(a, b, keySet, pathTracker) {
+        const objectDiffContext = new DiffContext();
+        const specialPathResult = [];
+        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;
+    }
+    specialPathHandle(isSame, specialPathResult, pathTracker) {
+        if (!isSame) {
+            return;
+        }
+        const specialPath = this.getSpecialPath(pathTracker);
+        if (this.existPath(specialPath)) {
+            specialPathResult.push(specialPath);
+        }
+    }
+    existPath(specialPath) {
+        return specialPath !== null;
+    }
+    getSpecialPath(pathTracker) {
+        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;
+    }
+    needDiff(noisePahList, pathList) {
+        if (!noisePahList || !pathList || noisePahList.length === 0 || pathList.length === 0) {
+            return true;
+        }
+        const path = this.listJoin(pathList);
+        if (noisePahList.includes(path)) {
+            return false;
+        }
+        return true;
+    }
+    listJoin(path) {
+        if (!path) {
+            throw new Error("当前路径不能为空");
+        }
+        const filtered = path.filter((e) => e.charAt(0) !== "[");
+        return filtered.join(MERGE_PATH);
+    }
+};
+AbstractObject = __decorate([
+    __param(0, Inject(IComparatorOrchestratorToken))
+], AbstractObject);
+export { AbstractObject };

package/dist/service/comparator/object/LeftJoinObjectComparator.d.ts

@@ -0,0 +1,8 @@
+import { AbstractObject } from "./AbstractObject";
+import { DiffContext } from "../../diff/DiffContext";
+import type { PathTracker } from "../../diff/PathTracker";
+import { type JsonObject, IComparatorOrchestrator } from "#contract";
+export declare class LeftJoinObjectComparator extends AbstractObject {
+    constructor(orchestrator: IComparatorOrchestrator);
+    diff(a: JsonObject, b: JsonObject, pathTracker: PathTracker): DiffContext;
+}

package/dist/service/comparator/object/LeftJoinObjectComparator.js

@@ -0,0 +1,25 @@
+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 { AbstractObject } from "./AbstractObject";
+import { DiffContext } from "../../diff/DiffContext";
+import { IComparatorOrchestrator } from "#contract";
+let LeftJoinObjectComparator = class LeftJoinObjectComparator extends AbstractObject {
+    constructor(orchestrator) {
+        super(orchestrator);
+    }
+    diff(a, b, pathTracker) {
+        return this.diffValueByKey(a, b, new Set(Object.keys(a)), pathTracker);
+    }
+};
+LeftJoinObjectComparator = __decorate([
+    __param(0, Inject(IComparatorOrchestrator))
+], LeftJoinObjectComparator);
+export { LeftJoinObjectComparator };

package/dist/service/comparator/object/UnionKeyObjectComparator.d.ts

@@ -0,0 +1,8 @@
+import { AbstractObject } from "./AbstractObject";
+import { DiffContext } from "../../diff/DiffContext";
+import type { PathTracker } from "../../diff/PathTracker";
+import type { JsonObject, IComparatorOrchestrator } from "../../../contract/type";
+export declare class UnionKeyObjectComparator extends AbstractObject {
+    constructor(orchestrator: IComparatorOrchestrator);
+    diff(a: JsonObject, b: JsonObject, pathTracker: PathTracker): DiffContext;
+}

package/dist/service/comparator/object/UnionKeyObjectComparator.js

@@ -0,0 +1,26 @@
+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 { AbstractObject } from "./AbstractObject";
+import { DiffContext } from "../../diff/DiffContext";
+import { IComparatorOrchestrator as IComparatorOrchestratorToken } from "../../../contract/type";
+let UnionKeyObjectComparator = class UnionKeyObjectComparator extends AbstractObject {
+    constructor(orchestrator) {
+        super(orchestrator);
+    }
+    diff(a, b, pathTracker) {
+        const unionSet = new Set([...Object.keys(a), ...Object.keys(b)]);
+        return this.diffValueByKey(a, b, unionSet, pathTracker);
+    }
+};
+UnionKeyObjectComparator = __decorate([
+    __param(0, Inject(IComparatorOrchestratorToken))
+], UnionKeyObjectComparator);
+export { UnionKeyObjectComparator };

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

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

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

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

package/dist/service/comparator/other/DefaultOtherComparator.d.ts

@@ -0,0 +1,6 @@
+import type { IOtherComparator, JsonValue } from "../../../contract/type";
+import { DiffContext } from "../../diff/DiffContext";
+import type { PathTracker } from "../../diff/PathTracker";
+export declare class DefaultOtherComparator implements IOtherComparator {
+    diff(a: JsonValue | undefined, b: JsonValue | undefined, pathTracker: PathTracker): DiffContext;
+}

package/dist/service/comparator/other/DefaultOtherComparator.js

@@ -0,0 +1,13 @@
+import { DiffContext } from "../../diff/DiffContext";
+import { SingleNodeDifference } from "../../../contract/type";
+import { DIFFERENT, MERGE_PATH } from "../../../contract/constant";
+import { jsonElement2Str } from "../../../util";
+export class DefaultOtherComparator {
+    diff(a, b, pathTracker) {
+        const otherDiffContext = new DiffContext(DIFFERENT);
+        const singleNodeDifferences = [];
+        singleNodeDifferences.push(new SingleNodeDifference(pathTracker.getLeftPath().join(MERGE_PATH), pathTracker.getRightPath().join(MERGE_PATH), jsonElement2Str(a), jsonElement2Str(b)));
+        otherDiffContext.setDiffResultModels(singleNodeDifferences);
+        return otherDiffContext;
+    }
+}

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

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

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

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

package/dist/service/comparator/primitive/DefaultPrimitiveComparator.d.ts

@@ -0,0 +1,6 @@
+import type { IPrimitiveComparator } from "../../../contract/type";
+import { DiffContext } from "../../diff/DiffContext";
+import type { PathTracker } from "../../diff/PathTracker";
+export declare class DefaultPrimitiveComparator implements IPrimitiveComparator {
+    diff(a: string | number | boolean, b: string | number | boolean, pathTracker: PathTracker): DiffContext;
+}

package/dist/service/comparator/primitive/DefaultPrimitiveComparator.js

@@ -0,0 +1,16 @@
+import { DiffContext } from "../../diff/DiffContext";
+import { SingleNodeDifference } from "../../../contract/type";
+import { DIFFERENT, MERGE_PATH } from "../../../contract/constant";
+import { jsonElement2Str } from "../../../util";
+export class DefaultPrimitiveComparator {
+    diff(a, b, pathTracker) {
+        const primitiveDiffContext = new DiffContext();
+        if (a !== b) {
+            const singleNodeDifferences = [];
+            singleNodeDifferences.push(new SingleNodeDifference(pathTracker.getLeftPath().join(MERGE_PATH), pathTracker.getRightPath().join(MERGE_PATH), jsonElement2Str(a), jsonElement2Str(b)));
+            primitiveDiffContext.setDiffResultModels(singleNodeDifferences);
+            primitiveDiffContext.setSame(DIFFERENT);
+        }
+        return primitiveDiffContext;
+    }
+}

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

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

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

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

package/dist/service/diff/DiffContext.d.ts

@@ -0,0 +1,13 @@
+import { SingleNodeDifference } from "../../contract/type";
+export declare class DiffContext {
+    private _isSame;
+    private singleNodeDifferences;
+    private specialPathResult;
+    constructor(isSame?: boolean);
+    isSame(): boolean;
+    setSame(same: boolean): void;
+    getDiffResultModels(): SingleNodeDifference[];
+    setDiffResultModels(singleNodeDifferences: SingleNodeDifference[]): void;
+    getSpecialPathResult(): string[] | null;
+    setSpecialPathResult(specialPathResult: string[]): void;
+}

package/dist/service/diff/DiffContext.js

@@ -0,0 +1,29 @@
+import { SingleNodeDifference } from "../../contract/type";
+export class DiffContext {
+    _isSame;
+    singleNodeDifferences;
+    specialPathResult;
+    constructor(isSame = true) {
+        this._isSame = isSame;
+        this.singleNodeDifferences = [];
+        this.specialPathResult = null;
+    }
+    isSame() {
+        return this._isSame;
+    }
+    setSame(same) {
+        this._isSame = same;
+    }
+    getDiffResultModels() {
+        return this.singleNodeDifferences;
+    }
+    setDiffResultModels(singleNodeDifferences) {
+        this.singleNodeDifferences = singleNodeDifferences;
+    }
+    getSpecialPathResult() {
+        return this.specialPathResult;
+    }
+    setSpecialPathResult(specialPathResult) {
+        this.specialPathResult = specialPathResult;
+    }
+}

package/dist/service/diff/DiffService.d.ts

@@ -0,0 +1,26 @@
+import { type JsonValue, Result, type IDiffService, IComparatorOrchestrator, IObjectComparator, IArrayComparator, IPrimitiveComparator, INullComparator, IOtherComparator, PresetName } from "#contract";
+export declare class DiffService implements IDiffService {
+    private config;
+    constructor(preset?: PresetName);
+    withObjectComparator(cls: new (orchestrator: IComparatorOrchestrator) => IObjectComparator): this;
+    withArrayComparator(cls: new (orchestrator: IComparatorOrchestrator) => IArrayComparator): this;
+    withPrimitiveComparator(cls: new () => IPrimitiveComparator): this;
+    withNullComparator(cls: new () => INullComparator): this;
+    withOtherComparator(cls: new () => IOtherComparator): this;
+    diffJson(leftJson: string, rightJson: string, options?: {
+        noisePath?: string[];
+        specialPath?: string[];
+        parseNestedJson?: boolean;
+    }): Result[];
+    diffElement(left: JsonValue, right: JsonValue, options?: {
+        noisePath?: string[];
+        specialPath?: string[];
+        parseNestedJson?: boolean;
+    }): Result[];
+    private getOrCreateOrchestrator;
+    private constructResult;
+    private convert;
+    private compareInternal;
+    private splitPath;
+    private parseNestedJsonStrings;
+}

package/dist/service/diff/DiffService.js

@@ -0,0 +1,184 @@
+import isJSON from "is-json";
+import { Injector } from "@wendellhu/redi";
+import { Result, SingleNodeDifference, IComparatorOrchestrator, IObjectComparator, IArrayComparator, IPrimitiveComparator, INullComparator, IOtherComparator, PresetName, } from "#contract";
+import { SPLIT_PATH, OBJECT_NULL, TYPE_MODIFY, TYPE_ADD, TYPE_DELETE } from "#contract";
+import { DiffContext } from "./DiffContext";
+import { PathTracker } from "./PathTracker";
+import { ComparatorOrchestrator } from "../comparator/ComparatorOrchestrator";
+import { UnionKeyObjectComparator } from "../comparator/object/UnionKeyObjectComparator";
+import { LeftJoinObjectComparator } from "../comparator/object/LeftJoinObjectComparator";
+import { SimilarArrayComparator } from "../comparator/array/SimilarArrayComparator";
+import { SequentialArrayComparator } from "../comparator/array/SequentialArrayComparator";
+import { DefaultPrimitiveComparator } from "../comparator/primitive/DefaultPrimitiveComparator";
+import { DefaultNullComparator } from "../comparator/nulls/DefaultNullComparator";
+import { DefaultOtherComparator } from "../comparator/other/DefaultOtherComparator";
+export class DiffService {
+    config;
+    constructor(preset = PresetName.FullSmart) {
+        this.config = {
+            objectComparator: UnionKeyObjectComparator,
+            arrayComparator: SimilarArrayComparator,
+            primitiveComparator: DefaultPrimitiveComparator,
+            nullComparator: DefaultNullComparator,
+            otherComparator: DefaultOtherComparator,
+        };
+        switch (preset) {
+            case PresetName.FullOrdered:
+                this.config.arrayComparator = SequentialArrayComparator;
+                break;
+            case PresetName.LeftSmart:
+                this.config.objectComparator = LeftJoinObjectComparator;
+                break;
+            case PresetName.LeftOrdered:
+                this.config.objectComparator = LeftJoinObjectComparator;
+                this.config.arrayComparator = SequentialArrayComparator;
+                break;
+            case PresetName.FullSmart:
+            default:
+                this.config.objectComparator = UnionKeyObjectComparator;
+                this.config.arrayComparator = SimilarArrayComparator;
+                break;
+        }
+    }
+    withObjectComparator(cls) {
+        this.config.objectComparator = cls;
+        return this;
+    }
+    withArrayComparator(cls) {
+        this.config.arrayComparator = cls;
+        return this;
+    }
+    withPrimitiveComparator(cls) {
+        this.config.primitiveComparator = cls;
+        return this;
+    }
+    withNullComparator(cls) {
+        this.config.nullComparator = cls;
+        return this;
+    }
+    withOtherComparator(cls) {
+        this.config.otherComparator = cls;
+        return this;
+    }
+    diffJson(leftJson, rightJson, options) {
+        let left;
+        let right;
+        try {
+            left = JSON.parse(leftJson);
+        }
+        catch (error) {
+            throw new Error(`Failed to parse left JSON string: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        try {
+            right = JSON.parse(rightJson);
+        }
+        catch (error) {
+            throw new Error(`Failed to parse right JSON string: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        // 将解析后的对象和选项传递给 diffElement
+        return this.diffElement(left, right, options);
+    }
+    diffElement(left, right, options) {
+        // 如果启用递归解析嵌套 JSON
+        if (options?.parseNestedJson) {
+            left = this.parseNestedJsonStrings(left);
+            right = this.parseNestedJsonStrings(right);
+        }
+        const orchestrator = this.getOrCreateOrchestrator();
+        const diffContext = this.compareInternal(left, right, orchestrator, options);
+        return this.constructResult(diffContext);
+    }
+    getOrCreateOrchestrator() {
+        const injector = new Injector([
+            [IComparatorOrchestrator, { useClass: ComparatorOrchestrator, lazy: true }],
+            [IObjectComparator, { useClass: this.config.objectComparator }],
+            [IArrayComparator, { useClass: this.config.arrayComparator }],
+            [IPrimitiveComparator, { useClass: this.config.primitiveComparator }],
+            [INullComparator, { useClass: this.config.nullComparator }],
+            [IOtherComparator, { useClass: this.config.otherComparator }],
+        ]);
+        return injector.get(IComparatorOrchestrator);
+    }
+    constructResult(diffContext) {
+        const list = [];
+        for (const resultModel of diffContext.getDiffResultModels()) {
+            const printModel = this.convert(resultModel);
+            const leftAndRightBothNull = resultModel.left === OBJECT_NULL && resultModel.right === OBJECT_NULL;
+            if (leftAndRightBothNull) {
+                printModel.diffType = TYPE_MODIFY;
+            }
+            else if (resultModel.left === OBJECT_NULL) {
+                printModel.diffType = TYPE_ADD;
+                printModel.leftPath = null;
+            }
+            else if (resultModel.right === OBJECT_NULL) {
+                printModel.diffType = TYPE_DELETE;
+                printModel.rightPath = null;
+            }
+            else {
+                printModel.diffType = TYPE_MODIFY;
+            }
+            list.push(printModel);
+        }
+        return list;
+    }
+    convert(resultModel) {
+        const printModel = new Result();
+        printModel.left = resultModel.left;
+        printModel.right = resultModel.right;
+        printModel.leftPath = resultModel.leftPath;
+        printModel.rightPath = resultModel.rightPath;
+        return printModel;
+    }
+    compareInternal(left, right, orchestrator, options) {
+        const pathTracker = new PathTracker(null, null);
+        if (options?.noisePath) {
+            pathTracker.setNoisePahList(this.splitPath(options.noisePath));
+        }
+        if (options?.specialPath) {
+            pathTracker.setSpecialPath(this.splitPath(options.specialPath));
+        }
+        return orchestrator.diffElement(left, right, pathTracker);
+    }
+    splitPath(pathList) {
+        const result = [];
+        for (const path of pathList) {
+            const parts = path.split(SPLIT_PATH);
+            result.push(parts.join("."));
+        }
+        return result;
+    }
+    parseNestedJsonStrings(value) {
+        // 如果是字符串，尝试解析为 JSON
+        if (typeof value === "string") {
+            if (isJSON(value)) {
+                try {
+                    const parsed = JSON.parse(value);
+                    // 递归处理解析后的值
+                    return this.parseNestedJsonStrings(parsed);
+                }
+                catch {
+                    // 如果解析失败，返回原字符串
+                    return value;
+                }
+            }
+            return value;
+        }
+        // 如果是数组，递归处理每个元素
+        if (Array.isArray(value)) {
+            return value.map(item => this.parseNestedJsonStrings(item));
+        }
+        // 如果是对象，递归处理每个属性值
+        if (typeof value === "object" && value !== null) {
+            const result = {};
+            for (const key in value) {
+                if (Object.prototype.hasOwnProperty.call(value, key)) {
+                    result[key] = this.parseNestedJsonStrings(value[key]);
+                }
+            }
+            return result;
+        }
+        // 其他类型（number, boolean, null）直接返回
+        return value;
+    }
+}

package/dist/service/diff/PathTracker.d.ts

@@ -0,0 +1,21 @@
+export declare class PathTracker {
+    private leftPath;
+    private rightPath;
+    private specialPath;
+    private noisePahList;
+    constructor(noisePahList?: string[] | null, specialPath?: string[] | null);
+    getNoisePahList(): string[] | null;
+    setNoisePahList(noisePahList: string[]): void;
+    getSpecialPath(): string[] | null;
+    setSpecialPath(specialPath: string[]): void;
+    getLeftPath(): string[];
+    setLeftPath(leftPath: string[]): void;
+    getRightPath(): string[];
+    setRightPath(rightPath: string[]): void;
+    addAllpath(lastPath: string): void;
+    addLeftPath(lastPath: string): void;
+    addRightPath(lastPath: string): void;
+    removeAllLastPath(): void;
+    removeLastLeftPath(): void;
+    removeLastRightPath(): void;
+}

package/dist/service/diff/PathTracker.js

@@ -0,0 +1,56 @@
+export class PathTracker {
+    leftPath;
+    rightPath;
+    specialPath;
+    noisePahList;
+    constructor(noisePahList = null, specialPath = null) {
+        this.leftPath = [];
+        this.rightPath = [];
+        this.noisePahList = noisePahList;
+        this.specialPath = specialPath;
+    }
+    getNoisePahList() {
+        return this.noisePahList;
+    }
+    setNoisePahList(noisePahList) {
+        this.noisePahList = noisePahList;
+    }
+    getSpecialPath() {
+        return this.specialPath;
+    }
+    setSpecialPath(specialPath) {
+        this.specialPath = specialPath;
+    }
+    getLeftPath() {
+        return this.leftPath;
+    }
+    setLeftPath(leftPath) {
+        this.leftPath = leftPath;
+    }
+    getRightPath() {
+        return this.rightPath;
+    }
+    setRightPath(rightPath) {
+        this.rightPath = rightPath;
+    }
+    addAllpath(lastPath) {
+        this.leftPath.push(lastPath);
+        this.rightPath.push(lastPath);
+    }
+    addLeftPath(lastPath) {
+        this.leftPath.push(lastPath);
+    }
+    addRightPath(lastPath) {
+        this.rightPath.push(lastPath);
+    }
+    removeAllLastPath() {
+        this.leftPath.pop();
+        this.rightPath.pop();
+    }
+    removeLastLeftPath() {
+        this.leftPath.pop();
+    }
+    removeLastRightPath() {
+        this.rightPath.pop();
+    }
+}

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

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

package/dist/service/diff/index.js

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

package/dist/service/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./diff";
+export * from "./comparator";

package/dist/service/index.js

@@ -0,0 +1,2 @@
+export * from "./diff";
+export * from "./comparator";

package/dist/util/TypeGuards.d.ts

@@ -0,0 +1,6 @@
+import type { JsonValue, JsonObject, JsonArray } from "../contract/type";
+export declare function isJsonObject(value: JsonValue | undefined): value is JsonObject;
+export declare function isJsonArray(value: JsonValue | undefined): value is JsonArray;
+export declare function isJsonPrimitive(value: JsonValue | undefined): value is string | number | boolean;
+export declare function isJsonNull(value: JsonValue | undefined): value is null;
+export declare function jsonElement2Str(element: JsonValue | undefined): string | null;