law-common 1.2.14 → 1.2.16

package/dist/entities/interface/client.entity.interface.d.ts

@@ -18,7 +18,7 @@ export interface IClientEntity extends IAuditColumnEntity {
 export interface IClientEntityDependent {
     partnerIds: number[];
 }
-export type IClientExclude = 'organizationId';
+export type IClientExclude = "organizationId";
 export interface IClientEntityCreateDto extends Omit<IEntityCreateDto<IClientEntity>, IClientExclude>, IClientEntityDependent {
 }
 export interface IClientEntityUpdateDto extends Omit<IEntityUpdateDto<IClientEntity>, IClientExclude>, Partial<IClientEntityDependent> {

package/dist/utils/helper.fn.util.d.ts

@@ -4,4 +4,79 @@ export declare function convertMapToObject<K, T>(map: Map<K, T>): {
     [key: string]: T;
 };
 export declare function removeSamePropertyValues(source: any, target: any): void;
+/**
+ * Removes elements from the target array that are present in the source array.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param {T[]} source - The array containing elements to be excluded from the target array.
+ * @param {T[]} target - The array from which elements will be filtered out.
+ * @returns {T[]} A new array containing elements from the target array that are not present in the source array.
+ *
+ * @example
+ * const source = [1, 2, 3];
+ * const target = [1, 2, 3, 4, 5, 6];
+ * const result = removeElementsFromArray(source, target);
+ * console.log(result); // Output: [4, 5, 6]
+ */
 export declare function removeElementsFromArray<T>(source: T[], target: T[]): T[];
+/**
+ * Returns a new array with elements from the target array that are not present in the source array.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param {T[]} source - The array containing elements to be excluded from the target array.
+ * @param {T[]} target - The array from which elements will be filtered out.
+ * @returns {T[]} A new array containing elements from the target array that are not present in the source array.
+ *
+ * @example
+ * const source = [1, 2, 3];
+ * const target = [1, 2, 3, 4, 5, 6];
+ * const result = arrayDifference(source, target);
+ * console.log(result); // Output: [4, 5, 6]
+ */
+export declare function arrayDifference<T>(source: T[], target: T[]): T[];
+/**
+ * Returns a new array containing elements that are present in both the source and target arrays.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param {T[]} source - The first array to compare.
+ * @param {T[]} target - The second array to compare.
+ * @returns {T[]} A new array containing elements that are present in both the source and target arrays.
+ *
+ * @example
+ * const source = [1, 2, 3];
+ * const target = [2, 3, 4];
+ * const result = arrayIntersection(source, target);
+ * console.log(result); // Output: [2, 3]
+ */
+export declare function arrayIntersection<T>(source: T[], target: T[]): T[];
+/**
+ * Returns a new array containing elements that are present in both the source and target arrays.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param {T[]} source - The first array to compare.
+ * @param {T[]} target - The second array to compare.
+ * @param {(a: T, b: T) => boolean} comparator - The function to determine if two elements are equal.
+ * @returns {T[]} A new array containing elements that are present in both the source and target arrays.
+ *
+ * @example
+ * const source = [{ id: 1, name: "John" }, { id: 2, name: "Jane" }];
+ * const target = [{ id: 2, name: "Jane" }, { id: 3, name: "Doe" }];
+ * const result = arrayIntersectionWith(source, target, (a, b) => a.id === b.id);
+ * console.log(result); // Output: [{ id: 2, name: "Jane" }]
+ */
+export declare function arrayIntersectionWith<T>(source: T[], target: T[], comparator: (a: T, b: T) => boolean): T[];
+/**
+ * Returns a new array containing elements that are present in either the source or target arrays.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param {T[]} source - The first array to compare.
+ * @param {T[]} target - The second array to compare.
+ * @returns {T[]} A new array containing elements that are present in either the source or target arrays.
+ *
+ * @example
+ * const source = [1, 2, 3];
+ * const target = [2, 3, 4];
+ * const result = arrayUnion(source, target);
+ * console.log(result); // Output: [1, 2, 3, 4]
+ */
+export declare function arrayUnion<T>(source: T[], target: T[]): T[];

package/dist/utils/helper.fn.util.js

@@ -5,6 +5,10 @@ exports.groupByOneToOneFunction = groupByOneToOneFunction;
 exports.convertMapToObject = convertMapToObject;
 exports.removeSamePropertyValues = removeSamePropertyValues;
 exports.removeElementsFromArray = removeElementsFromArray;
+exports.arrayDifference = arrayDifference;
+exports.arrayIntersection = arrayIntersection;
+exports.arrayIntersectionWith = arrayIntersectionWith;
+exports.arrayUnion = arrayUnion;
 function groupByFunction(list, keyGetter) {
     const map = new Map();
     list.forEach((item) => {
@@ -37,6 +41,90 @@ function removeSamePropertyValues(source, target) {
         }
     }
 }
+/**
+ * Removes elements from the target array that are present in the source array.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param {T[]} source - The array containing elements to be excluded from the target array.
+ * @param {T[]} target - The array from which elements will be filtered out.
+ * @returns {T[]} A new array containing elements from the target array that are not present in the source array.
+ *
+ * @example
+ * const source = [1, 2, 3];
+ * const target = [1, 2, 3, 4, 5, 6];
+ * const result = removeElementsFromArray(source, target);
+ * console.log(result); // Output: [4, 5, 6]
+ */
 function removeElementsFromArray(source, target) {
     return target.filter((element) => !source.includes(element));
 }
+/**
+ * Returns a new array with elements from the target array that are not present in the source array.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param {T[]} source - The array containing elements to be excluded from the target array.
+ * @param {T[]} target - The array from which elements will be filtered out.
+ * @returns {T[]} A new array containing elements from the target array that are not present in the source array.
+ *
+ * @example
+ * const source = [1, 2, 3];
+ * const target = [1, 2, 3, 4, 5, 6];
+ * const result = arrayDifference(source, target);
+ * console.log(result); // Output: [4, 5, 6]
+ */
+function arrayDifference(source, target) {
+    return target.filter((element) => !source.includes(element));
+}
+/**
+ * Returns a new array containing elements that are present in both the source and target arrays.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param {T[]} source - The first array to compare.
+ * @param {T[]} target - The second array to compare.
+ * @returns {T[]} A new array containing elements that are present in both the source and target arrays.
+ *
+ * @example
+ * const source = [1, 2, 3];
+ * const target = [2, 3, 4];
+ * const result = arrayIntersection(source, target);
+ * console.log(result); // Output: [2, 3]
+ */
+function arrayIntersection(source, target) {
+    return target.filter((element) => source.includes(element));
+}
+// js docs
+/**
+ * Returns a new array containing elements that are present in both the source and target arrays.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param {T[]} source - The first array to compare.
+ * @param {T[]} target - The second array to compare.
+ * @param {(a: T, b: T) => boolean} comparator - The function to determine if two elements are equal.
+ * @returns {T[]} A new array containing elements that are present in both the source and target arrays.
+ *
+ * @example
+ * const source = [{ id: 1, name: "John" }, { id: 2, name: "Jane" }];
+ * const target = [{ id: 2, name: "Jane" }, { id: 3, name: "Doe" }];
+ * const result = arrayIntersectionWith(source, target, (a, b) => a.id === b.id);
+ * console.log(result); // Output: [{ id: 2, name: "Jane" }]
+ */
+function arrayIntersectionWith(source, target, comparator) {
+    return target.filter((element) => source.some((item) => comparator(item, element)));
+}
+/**
+ * Returns a new array containing elements that are present in either the source or target arrays.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param {T[]} source - The first array to compare.
+ * @param {T[]} target - The second array to compare.
+ * @returns {T[]} A new array containing elements that are present in either the source or target arrays.
+ *
+ * @example
+ * const source = [1, 2, 3];
+ * const target = [2, 3, 4];
+ * const result = arrayUnion(source, target);
+ * console.log(result); // Output: [1, 2, 3, 4]
+ */
+function arrayUnion(source, target) {
+    return [...new Set([...source, ...target])];
+}

package/package.json

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