law-common 10.28.2-beta.1 → 10.28.2-beta.11

package/dist/src/api/enums/crud.enum.d.ts

@@ -0,0 +1,7 @@
+export declare enum CRUDEnum {
+    CREATE = "CREATE",
+    READ = "READ",
+    UPDATE = "UPDATE",
+    DELETE = "DELETE",
+    UNCHANGED = "UNCHANGED"
+}

package/dist/src/api/enums/crud.enum.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CRUDEnum = void 0;
+var CRUDEnum;
+(function (CRUDEnum) {
+    CRUDEnum["CREATE"] = "CREATE";
+    CRUDEnum["READ"] = "READ";
+    CRUDEnum["UPDATE"] = "UPDATE";
+    CRUDEnum["DELETE"] = "DELETE";
+    CRUDEnum["UNCHANGED"] = "UNCHANGED";
+})(CRUDEnum || (exports.CRUDEnum = CRUDEnum = {}));

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

@@ -49,3 +49,6 @@ export * from "./interface/work.from.home.update.interface";
 export * from "./interface/cron-job-manual-trigger.dto.interface";
 export * from "./interface/cron-job.entity.response";
 export * from "./interface/address-book.create.dto.interface";
+export * from "./enums/crud.enum";
+export * from "./interface/api.utils.interface";
+export * from "./interface/address-book.update.dto.interface";

package/dist/src/api/index.js

@@ -69,3 +69,6 @@ __exportStar(require("./interface/cron-job.entity.response"), exports);
 // export * from "./interface/billing-reimbursement-expense-history.api";
 // export * from "./interface/project-user-mapping.entity.api";
 __exportStar(require("./interface/address-book.create.dto.interface"), exports);
+__exportStar(require("./enums/crud.enum"), exports);
+__exportStar(require("./interface/api.utils.interface"), exports);
+__exportStar(require("./interface/address-book.update.dto.interface"), exports);

package/dist/src/api/interface/address-book.create.dto.interface.d.ts

@@ -1,10 +1,12 @@
 import { IAddressBookEntity, IEntityCreateDto } from "../../entities";
+import { CRUDEnum } from "../enums/crud.enum";
 export type IAddressBookCreateExclude = "contactDetails" | "address" | "organizationId";
 export interface IAddressBookContactDetail {
     id?: number;
     name: string;
     email?: string;
     phone?: string;
+    operation: CRUDEnum;
 }
 export interface IAddressBookAddress {
     addressLine1?: string;

package/dist/src/api/interface/address-book.update.dto.interface.d.ts

@@ -0,0 +1,3 @@
+import { IAddressBookCreateDto } from "./address-book.create.dto.interface";
+import { DeepPartialButRequired } from "./api.utils.interface";
+export type IAddressBookUpdateDto = DeepPartialButRequired<IAddressBookCreateDto, never>;

package/dist/src/api/interface/address-book.update.dto.interface.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// export type IAddressBookUpdateDto = DeepPartialButRequired<
+//     Omit<IAddressBookCreateDto, 'contactDetails'>,
+//     never
+// > & {
+//     contactDetails?: DeepPartialButRequired<IAddressBookContactDetail, 'id'>[];  // id required per item
+//     // address?: DeepPartial<IAddressBookAddress>;
+// };
+// const a: IAddressBookUpdateDto = {
+//     organizationName: "Test Name",
+//     contactDetails: [
+//         {
+//             id: 1,
+//             email: "test@example.com",
+//             phone: "123-456-7890"
+//         }
+//     ]
+// };
+// const b: IAddressBookUpdateDto = {
+//     organizationName: "Test Name",
+//     address: {
+//         city: "Sample City"
+//     }
+// };

package/dist/src/api/interface/api.utils.interface.d.ts

@@ -0,0 +1,4 @@
+export type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: T[P] extends Array<infer U> ? Array<DeepPartial<U>> : T[P] extends object ? DeepPartial<T[P]> : T[P];
+} : T;
+export type DeepPartialButRequired<T, K extends keyof T> = DeepPartial<T> & Required<Pick<T, K>>;

package/dist/src/api/interface/api.utils.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/entities/model/base.entity.model.d.ts

@@ -4,7 +4,7 @@ export declare enum RelationType {
     MANY = "many"
 }
 export declare abstract class BaseEntityModel<T extends EntityEnum | VirtualEntityEnum> {
-    protected entityName: T;
+    readonly entityName: T;
     constructor(entityName: T);
     abstract getRelationConfigs(): any[];
     populateRelationsByIndex(entityIndexMap: EntityIndexMap): void;

package/dist/src/entities/model/entity.model.interface.d.ts

@@ -1,4 +1,5 @@
 import { EntityEnum, EntityIndexMap, EntityMap, EnumEntityType, EnumToModel, IApiEntity, IBaseEntityApiResponse, VirtualEntityEnum } from "../interface/entity.utils.interface";
+import { BaseEntityModel } from "./base.entity.model";
 export declare function mapToIndex(entityMap: EntityMap): EntityIndexMap;
 export declare function getEntityIndexMap<T extends EntityEnum>(data: IBaseEntityApiResponse<EnumEntityType<T>>, baseEntity: T, reusedConfig?: {
     existingEntityIndexMap: EntityIndexMap;
@@ -16,3 +17,26 @@ export declare function parseEntitiesWithoutModels<T extends EnumEntityType<Enti
 }): {
     [E in EntityEnum | VirtualEntityEnum]?: IApiEntity<EnumEntityType<E>>[];
 };
+export declare function removeEntityById(entityIndexMap: EntityIndexMap, entity: EntityEnum, id: number): void;
+export declare class EntityModelRelationHelper {
+    entityMap: EntityMap;
+    entityModelMap: EntityMap;
+    entityModelIndexMap: EntityIndexMap;
+    constructor(entityMap: EntityMap);
+    private init;
+    private toEntityModelMap;
+    fromEntityToEntityModel<T extends EntityEnum | VirtualEntityEnum>(entity: EnumEntityType<T>, entityEnum: T): BaseEntityModel<T>;
+    private toEntityModelIndexMap;
+    populateRelationsByEntityEnums(entityEnums: EntityEnum[]): EntityModelRelationHelper;
+    populateRelationsByEntityEnum(entityEnum: EntityEnum): void;
+    populateRelationsByEntityModel(entityModel: BaseEntityModel<EntityEnum | VirtualEntityEnum>): void;
+    addEntityModel<T extends EntityEnum | VirtualEntityEnum>(entityModel: BaseEntityModel<T>, config?: {
+        populateRelations?: boolean;
+    }): void;
+    addEntity<T extends EntityEnum | VirtualEntityEnum>(entity: EnumEntityType<T>, entityEnum: T, config?: {
+        populateRelations?: boolean;
+    }): void;
+    updateEntityModel<T extends EntityEnum | VirtualEntityEnum>(entityModel: BaseEntityModel<T>, config?: {
+        populateRelations?: boolean;
+    }): void;
+}

package/dist/src/entities/model/entity.model.interface.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.entityEnumToEntityModel = void 0;
+exports.EntityModelRelationHelper = exports.entityEnumToEntityModel = void 0;
 exports.mapToIndex = mapToIndex;
 exports.getEntityIndexMap = getEntityIndexMap;
 exports.populateRelationsFor = populateRelationsFor;
@@ -8,6 +8,7 @@ exports.entityMapToModels = entityMapToModels;
 exports.parseEntities = parseEntities;
 exports.entityMapToEntityIndexMap = entityMapToEntityIndexMap;
 exports.parseEntitiesWithoutModels = parseEntitiesWithoutModels;
+exports.removeEntityById = removeEntityById;
 const entity_utils_interface_1 = require("../interface/entity.utils.interface");
 const bank_entity_model_1 = require("./bank.entity.model");
 const base_entity_model_1 = require("./base.entity.model");
@@ -125,3 +126,88 @@ function parseEntitiesWithoutModels(json, baseEntity, entityMap = {}) {
     }
     return entityMap;
 }
+function removeEntityById(entityIndexMap, entity, id) {
+    if (entityIndexMap[entity]) {
+        delete entityIndexMap[entity][id];
+    }
+}
+class EntityModelRelationHelper {
+    constructor(entityMap) {
+        this.entityMap = entityMap;
+        this.entityModelMap = {};
+        this.entityModelIndexMap = {};
+        this.init();
+    }
+    init() {
+        this.toEntityModelMap();
+        this.toEntityModelIndexMap();
+    }
+    toEntityModelMap() {
+        for (const entityName in this.entityMap) {
+            if (!(entityName in exports.entityEnumToEntityModel)) {
+                throw new Error(`Unknown entity: ${entityName}`);
+            }
+            this.entityModelMap[entityName] = this.entityMap[entityName].map((entity) => 
+            // @ts-ignore
+            exports.entityEnumToEntityModel[entityName](entity));
+        }
+        return this;
+    }
+    fromEntityToEntityModel(entity, entityEnum) {
+        if (!(entityEnum in exports.entityEnumToEntityModel)) {
+            throw new Error(`Unknown entity: ${entityEnum}`);
+        }
+        return exports.entityEnumToEntityModel[entityEnum](entity);
+    }
+    toEntityModelIndexMap() {
+        this.entityModelIndexMap = Object.keys(this.entityModelMap).reduce((acc, key) => {
+            // @ts-ignore
+            acc[key] = this.entityModelMap[key].reduce((innerAcc, entity) => {
+                innerAcc[entity.id] = entity;
+                return innerAcc;
+            }, {});
+            return acc;
+        }, {});
+        return this;
+    }
+    populateRelationsByEntityEnums(entityEnums) {
+        entityEnums.forEach((entityEnum) => {
+            this.populateRelationsByEntityEnum(entityEnum);
+        });
+        return this;
+    }
+    populateRelationsByEntityEnum(entityEnum) {
+        for (const key of Object.keys(this.entityModelIndexMap[entityEnum] || {})) {
+            const entityModel = this.entityModelIndexMap[entityEnum][key];
+            entityModel.populateRelationsByIndex(this.entityModelIndexMap);
+        }
+    }
+    populateRelationsByEntityModel(entityModel) {
+        entityModel.populateRelationsByIndex(this.entityModelIndexMap);
+    }
+    addEntityModel(entityModel, config = { populateRelations: false }) {
+        const entityEnum = entityModel.entityName;
+        this.entityModelIndexMap[entityEnum] = this.entityModelIndexMap[entityEnum] || {};
+        // @ts-ignore
+        this.entityModelIndexMap[entityEnum][entityModel.id] = entityModel;
+        if (config.populateRelations) {
+            this.populateRelationsByEntityModel(entityModel);
+        }
+    }
+    addEntity(entity, entityEnum, config = { populateRelations: false }) {
+        if (!(entityEnum in exports.entityEnumToEntityModel)) {
+            throw new Error(`Unknown entity: ${entityEnum}`);
+        }
+        this.addEntityModel(this.fromEntityToEntityModel(entity, entityEnum), config);
+    }
+    updateEntityModel(entityModel, config = { populateRelations: false }) {
+        const entityEnum = entityModel.entityName;
+        this.entityModelIndexMap[entityEnum] = this.entityModelIndexMap[entityEnum] || {};
+        // @ts-ignore
+        this.entityModelIndexMap[entityEnum][entityModel.id] = entityModel;
+        if (config.populateRelations) {
+            this.populateRelationsByEntityModel(entityModel);
+        }
+    }
+}
+exports.EntityModelRelationHelper = EntityModelRelationHelper;

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

@@ -0,0 +1,25 @@
+export type ArrayComparisonCategory<T> = {
+    unchanged: T[];
+    added: T[];
+    updated: T[];
+    deleted: {
+        [x: string]: T[keyof T];
+    }[];
+    notFound: {
+        [x: string]: T[keyof T];
+    }[];
+};
+export declare class ArrayComparisonCategorizer<T> {
+    private incomingArray;
+    private existingArray;
+    private keyProperty;
+    private arrayComparisonCategory;
+    constructor(incomingArray: T[] | undefined, existingArray: T[] | undefined, keyProperty: keyof T);
+    private get existingMap();
+    private isExistingItem;
+    private isMarkForDeletion;
+    private isIdentifierPresent;
+    compare(): ArrayComparisonCategory<T>;
+    get category(): ArrayComparisonCategory<T> | null;
+    merge(): T[];
+}

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

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayComparisonCategorizer = 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]));
+}
+class ArrayComparisonCategorizer {
+    constructor(incomingArray = [], existingArray = [], keyProperty) {
+        this.arrayComparisonCategory = null;
+        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]));
+    }
+    isExistingItem(incomingItem, existingMap) {
+        return existingMap.has(incomingItem[this.keyProperty]);
+    }
+    isMarkForDeletion(incomingItem) {
+        const onlyIdentifierPresent = Object.keys(incomingItem).length === 1;
+        return this.isIdentifierPresent(incomingItem) && onlyIdentifierPresent;
+    }
+    isIdentifierPresent(incomingItem) {
+        return incomingItem[this.keyProperty] !== undefined && incomingItem[this.keyProperty] !== null;
+    }
+    compare() {
+        const existingMap = this.existingMap;
+        const unchanged = [];
+        const added = [];
+        const updated = [];
+        const deleted = [];
+        const notFound = [];
+        for (const incomingItem of this.incomingArray) {
+            const isIdentifierPresent = this.isIdentifierPresent(incomingItem);
+            const isMarkForDeletion = isIdentifierPresent && this.isMarkForDeletion(incomingItem);
+            const isExistingItem = isIdentifierPresent && this.isExistingItem(incomingItem, existingMap);
+            const existingItem = isExistingItem ? existingMap.get(incomingItem[this.keyProperty]) : null;
+            if (isMarkForDeletion) {
+                deleted.push({ [this.keyProperty]: incomingItem[this.keyProperty] });
+            }
+            else if (!isIdentifierPresent && !isExistingItem) {
+                added.push(incomingItem);
+            }
+            else if (isExistingItem && isIdentifierPresent) {
+                if (deepEqual(incomingItem, existingItem)) {
+                    unchanged.push(incomingItem);
+                }
+                else {
+                    updated.push(incomingItem);
+                }
+            }
+            else {
+                notFound.push({ [this.keyProperty]: incomingItem[this.keyProperty] });
+            }
+        }
+        const result = {
+            unchanged,
+            added,
+            updated,
+            deleted,
+            notFound
+        };
+        this.arrayComparisonCategory = result;
+        return result;
+    }
+    get category() {
+        return this.arrayComparisonCategory;
+    }
+    merge() {
+        if (!this.arrayComparisonCategory) {
+            throw new Error("ArrayComparisonCategory is not computed yet. Call compare() first.");
+        }
+        const changes = this.arrayComparisonCategory;
+        let newState = this.existingArray.filter(this.isIdentifierPresent.bind(this));
+        // Remove deleted items
+        const deletedIds = new Set(changes.deleted.map((d) => d[this.keyProperty]));
+        newState = newState.filter((item) => !deletedIds.has(item[this.keyProperty]));
+        // Update items
+        for (let i = 0; i < newState.length; i++) {
+            const item = newState[i];
+            const updatedItem = changes.updated.find((u) => u[this.keyProperty] === item[this.keyProperty]);
+            if (updatedItem) {
+                newState[i] = updatedItem;
+            }
+        }
+        // Get Max Id
+        const existingWithId = this.existingArray.filter(this.isIdentifierPresent.bind(this));
+        const originalMaxId = existingWithId.length > 0
+            ? Math.max(...existingWithId.map((item) => item[this.keyProperty]))
+            : 0;
+        // Add new items with new identifier
+        let currentMaxId = originalMaxId;
+        for (const item of changes.added) {
+            const id = ++currentMaxId;
+            newState.push(Object.assign(Object.assign({}, item), { [this.keyProperty]: id }));
+        }
+        return newState;
+    }
+}
+exports.ArrayComparisonCategorizer = ArrayComparisonCategorizer;
+// function categorizeChanges<T extends Item>(
+//   incoming: T[],
+//   existing: T[]
+// ): {
+//   unchanged: T[];
+//   added: T[];
+//   updated: T[];
+//   deleted: { id: number }[];
+//   notFound: { id: number }[];
+// } {
+//   console.log("Categorizing changes between incoming and existing items");
+//   console.log("Incoming items:", incoming);
+//   console.log("Existing items:", existing);
+//   const existingMap = new Map<number, T>(existing.filter((item) => item.id !== undefined).map((item) => [item.id!, item]));
+//   const incomingIds = new Set<number>(incoming.filter((item) => item.id !== undefined).map((item) => item.id!));
+//   const deleted: { id: number }[] = [];
+//   const notFound: { id: number }[] = [];
+//   const unchanged: T[] = [];
+//   const updated: T[] = [];
+//   const added: T[] = [];
+//   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 };
+// }

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/dist/src/utils/object.util.d.ts

@@ -0,0 +1,10 @@
+interface ComparableObject {
+    [key: string]: any;
+}
+declare class ObjectComparator {
+    private incoming;
+    private existing;
+    constructor(incoming: ComparableObject, existing: ComparableObject);
+    compare(): ComparableObject;
+    private deepDiff;
+}

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

@@ -0,0 +1,134 @@
+"use strict";
+class ObjectComparator {
+    constructor(incoming, existing) {
+        this.incoming = incoming;
+        this.existing = existing;
+    }
+    compare() {
+        return this.deepDiff(this.incoming, this.existing);
+    }
+    deepDiff(a, b) {
+        // Handle null/undefined cases
+        if (a == null && b == null) {
+            return undefined;
+        }
+        if (a == null || b == null) {
+            return a;
+        }
+        // Handle primitives (loose equality)
+        if (typeof a !== "object") {
+            return a == b ? undefined : a;
+        }
+        // a is object or array
+        if (Array.isArray(a)) {
+            // Handle as array
+            const diffArr = new Array(a.length);
+            let hasDiff = false;
+            for (let i = 0; i < a.length; i++) {
+                const subB = Array.isArray(b) && i < b.length ? b[i] : undefined;
+                const subDiff = this.deepDiff(a[i], subB);
+                if (subDiff !== undefined) {
+                    diffArr[i] = subDiff;
+                    hasDiff = true;
+                }
+            }
+            return hasDiff ? diffArr : undefined;
+        }
+        else {
+            // Handle as object
+            const diff = {};
+            let hasDiff = false;
+            for (const key of Object.keys(a)) {
+                const subDiff = this.deepDiff(a[key], b === null || b === void 0 ? void 0 : b[key]);
+                if (subDiff !== undefined) {
+                    diff[key] = subDiff;
+                    hasDiff = true;
+                }
+            }
+            return hasDiff ? diff : undefined;
+        }
+    }
+}
+// // Comprehensive Usage Examples
+// // Example 1: Simple object with primitive differences
+// console.log("Example 1: Simple object");
+// const incoming1 = { name: "Alice", age: 30, city: "New York" };
+// const existing1 = { name: "Bob", age: 30, city: "Boston" };
+// const comparator1 = new ObjectComparator(incoming1, existing1);
+// console.log(comparator1.compare()); // Output: { name: 'Alice', city: 'New York' }
+// // Example 2: Nested objects
+// console.log("Example 2: Nested objects");
+// const incoming2 = {
+//   user: { id: 1, profile: { email: "alice@example.com", phone: "123-456" } },
+//   settings: { theme: "dark", notifications: true },
+// };
+// const existing2 = {
+//   user: { id: 1, profile: { email: "bob@example.com" } },
+//   settings: { theme: "light" },
+// };
+// const comparator2 = new ObjectComparator(incoming2, existing2);
+// console.log(comparator2.compare());
+// // Output: {
+// //   user: { profile: { email: 'alice@example.com', phone: '123-456' } },
+// //   settings: { theme: 'dark', notifications: true }
+// // }
+// // Example 3: Array of primitives
+// console.log("Example 3: Array of primitives");
+// const incoming3 = { scores: [95, 87, 100] };
+// const existing3 = { scores: [80, 87, 90] };
+// const comparator3 = new ObjectComparator(incoming3, existing3);
+// console.log(comparator3.compare()); // Output: { scores: [95, undefined, 100] }
+// // Example 4: Array of objects
+// console.log("Example 4: Array of objects");
+// const incoming4 = {
+//   items: [
+//     { id: 1, name: "Item A", price: 10 },
+//     { id: 2, name: "Item B", price: 20 },
+//     { id: 3, name: "Item C", price: 30 },
+//   ],
+// };
+// const existing4 = {
+//   items: [
+//     { id: 1, name: "Item A", price: 15 },
+//     { id: 2, name: "Item X", price: 20 },
+//   ],
+// };
+// const comparator4 = new ObjectComparator(incoming4, existing4);
+// console.log(comparator4.compare());
+// // Output: {
+// //   items: [
+// //     { price: 10 },
+// //     { name: 'Item B' },
+// //     { id: 3, name: 'Item C', price: 30 }
+// //   ]
+// // }
+// // Example 5: Mixed structure with missing properties and nulls
+// console.log("Example 5: Mixed with nulls and missing");
+// const incoming5 = {
+//   data: {
+//     value: null,
+//     list: [1, 2, { nested: "hello" }],
+//     extra: "new",
+//   },
+// };
+// const existing5 = {
+//   data: {
+//     value: 42,
+//     list: [1, 3],
+//   },
+// };
+// const comparator5 = new ObjectComparator(incoming5, existing5);
+// console.log(comparator5.compare());
+// // Output: {
+// //   data: {
+// //     value: null,
+// //     list: [undefined, 2, { nested: 'hello' }],
+// //     extra: 'new'
+// //   }
+// // }
+// // Example 6: No differences
+// console.log("Example 6: No differences");
+// const incoming6 = { a: 1, b: { c: [true] } };
+// const existing6 = { a: 1, b: { c: [true] } };
+// const comparator6 = new ObjectComparator(incoming6, existing6);
+// console.log(comparator6.compare()); // Output: {}

package/package.json

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