law-common 10.28.2-beta.7 → 10.28.2-beta.8

package/dist/src/utils/array.util.d.ts

@@ -0,0 +1,21 @@
+export declare class ArrayChangeTracker<T> {
+    private incomingArray;
+    private existingArray;
+    private keyProperty;
+    private unchanged;
+    private added;
+    private updated;
+    private deleted;
+    private notFound;
+    constructor(incomingArray: T[] | undefined, existingArray: T[] | undefined, keyProperty: keyof T);
+    private get existingMap();
+    unchangedItems(): T[];
+    addedItems(): T[];
+    updatedItems(): T[];
+    deletedItems(): {
+        id: T[keyof T];
+    }[];
+    notFoundItems(): {
+        id: T[keyof T];
+    }[];
+}

package/dist/src/utils/array.util.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayChangeTracker = void 0;
+function deepEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a == null || b == null)
+        return false;
+    if (typeof a !== typeof b)
+        return false;
+    if (typeof a !== "object")
+        return a === b;
+    if (Array.isArray(a) !== Array.isArray(b))
+        return false;
+    if (Array.isArray(a)) {
+        if (a.length !== b.length)
+            return false;
+        return a.every((v, i) => deepEqual(v, b[i]));
+    }
+    const keysA = Object.keys(a).sort();
+    const keysB = Object.keys(b).sort();
+    if (keysA.length !== keysB.length)
+        return false;
+    return keysA.every((key) => deepEqual(a[key], b[key]));
+}
+function categorizeChanges(incoming, existing) {
+    console.log("Categorizing changes between incoming and existing items");
+    console.log("Incoming items:", incoming);
+    console.log("Existing items:", existing);
+    const existingMap = new Map(existing.filter((item) => item.id !== undefined).map((item) => [item.id, item]));
+    const incomingIds = new Set(incoming.filter((item) => item.id !== undefined).map((item) => item.id));
+    const deleted = [];
+    const notFound = [];
+    const unchanged = [];
+    const updated = [];
+    const added = [];
+    for (const item of incoming) {
+        if (item.id === undefined) {
+            added.push(item);
+            continue;
+        }
+        const id = item.id;
+        if (Object.keys(item).length === 1) {
+            deleted.push({ id });
+            continue;
+        }
+        if (!existingMap.has(id)) {
+            added.push(item);
+            continue;
+        }
+        const existingItem = existingMap.get(id);
+        if (deepEqual(item, existingItem)) {
+            unchanged.push(item);
+        }
+        else {
+            updated.push(item);
+        }
+    }
+    for (const [id] of existingMap) {
+        if (!incomingIds.has(id)) {
+            notFound.push({ id });
+        }
+    }
+    return { unchanged, added, updated, deleted, notFound };
+}
+class ArrayChangeTracker {
+    constructor(incomingArray = [], existingArray = [], keyProperty) {
+        this.unchanged = [];
+        this.added = [];
+        this.updated = [];
+        this.deleted = [];
+        this.notFound = [];
+        this.incomingArray = [...incomingArray];
+        this.existingArray = [...existingArray];
+        this.keyProperty = keyProperty;
+    }
+    get existingMap() {
+        return new Map(this.existingArray.filter((item) => item[this.keyProperty] !== undefined).map((item) => [item[this.keyProperty], item]));
+    }
+    unchangedItems() {
+        const existingMap = this.existingMap;
+        this.unchanged = [];
+        for (const incomingItem of this.incomingArray) {
+            const isIdentifierPresent = incomingItem[this.keyProperty] !== undefined && incomingItem[this.keyProperty] !== null;
+            const onlyIdentifierPresent = Object.keys(incomingItem).length === 1;
+            const isExistingItem = existingMap.has(incomingItem[this.keyProperty]);
+            if (!isIdentifierPresent || !isExistingItem || onlyIdentifierPresent) {
+                continue;
+            }
+            const id = incomingItem[this.keyProperty];
+            const existingItem = existingMap.get(id);
+            if (deepEqual(incomingItem, existingItem)) {
+                this.unchanged.push(incomingItem);
+            }
+        }
+        return this.unchanged;
+    }
+    addedItems() {
+        this.added = [];
+        const existingMap = this.existingMap;
+        for (const incomingItem of this.incomingArray) {
+            if (!existingMap.has(incomingItem[this.keyProperty])) {
+                this.added.push(incomingItem);
+                continue;
+            }
+        }
+        return this.added;
+    }
+    updatedItems() {
+        this.updated = [];
+        const existingMap = this.existingMap;
+        for (const incomingItem of this.incomingArray) {
+            const isExistingItem = existingMap.has(incomingItem[this.keyProperty]);
+            if (!isExistingItem) {
+                continue;
+            }
+            const id = incomingItem[this.keyProperty];
+            const existingItem = existingMap.get(id);
+            if (!deepEqual(incomingItem, existingItem)) {
+                this.updated.push(incomingItem);
+            }
+        }
+        return this.updated;
+    }
+    deletedItems() {
+        this.deleted = [];
+        for (const incomingItem of this.incomingArray) {
+            const isIdentifierPresent = incomingItem[this.keyProperty] !== undefined && incomingItem[this.keyProperty] !== null;
+            const onlyIdentifierPresent = Object.keys(incomingItem).length === 1;
+            if (isIdentifierPresent && onlyIdentifierPresent) {
+                this.deleted.push({ id: incomingItem[this.keyProperty] });
+            }
+        }
+        return this.deleted;
+    }
+    notFoundItems() {
+        this.notFound = [];
+        const existingMap = this.existingMap;
+        for (const incomingItem of this.existingArray) {
+            const isIdentifierPresent = incomingItem[this.keyProperty] !== undefined && incomingItem[this.keyProperty] !== null;
+            if (isIdentifierPresent && !existingMap.has(incomingItem[this.keyProperty])) {
+                this.notFound.push({ id: incomingItem[this.keyProperty] });
+            }
+        }
+        return this.notFound;
+    }
+}
+exports.ArrayChangeTracker = ArrayChangeTracker;

package/dist/src/utils/index.d.ts

@@ -3,3 +3,4 @@ export * from "./helper.fn.util";
 export * from "./models/date-code.model.util";
 export * from "./string.util";
 export * from "./entity.flow.util";
+export * from "./array.util";

package/dist/src/utils/index.js

@@ -19,3 +19,4 @@ __exportStar(require("./helper.fn.util"), exports);
 __exportStar(require("./models/date-code.model.util"), exports);
 __exportStar(require("./string.util"), exports);
 __exportStar(require("./entity.flow.util"), exports);
+__exportStar(require("./array.util"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
  "name": "law-common",
- "version": "10.28.2-beta.7",
+ "version": "10.28.2-beta.8",
  "description": "",
  "main": "dist/index.js",
  "files": [