@startinblox/components-ds4go 2.3.0 → 3.0.0

package/src/helpers/components/setupOnSaveReset.ts

@@ -2,18 +2,40 @@
 Common code for components
 Handle cache invalidation based on keywords
 */
-const setupOnSaveReset = (component: any, { keywords = [] } = {}) => {
-  if (keywords) {
+const setupOnSaveReset = (component: any, { keywords = [] as string[] } = {}) => {
+  const setup = () => {
+    if (!keywords.length) return;
+
+    const keywordSet = new Set(keywords);
+
     component.saveListener = (e: Event) => {
-      const resource = e.detail.id || e.detail.resource["@id"];
-      if (keywords.some((keyword) => resource?.includes(keyword))) {
+      const resource = e.detail.id || e.detail.resource?.["@id"];
+      if (!resource) return;
+
+      const isMatch = Array.from(keywordSet).some((keyword) => {
+        const idx = resource.indexOf(keyword);
+        return idx !== -1 && (idx === 0 || resource[idx - 1] === "/");
+      });
+
+      if (isMatch) {
         component._setValue({ target: { value: "" } });
       }
     };
 
     component._subscriptions.add(["save", component.saveListener]);
-
     component._subscribe();
+  };
+
+  if (document.readyState !== "complete") {
+    const listener = () => {
+      if (document.readyState === "complete") {
+        document.removeEventListener("readystatechange", listener);
+        setup();
+      }
+    };
+    document.addEventListener("readystatechange", listener);
+  } else {
+    setup();
   }
 };
 

package/src/helpers/datas/checkValueInIntervalRecursive.ts

@@ -0,0 +1,66 @@
+function isValidDateValue(value: unknown): value is string | number | Date {
+  if (
+    typeof value !== "string" &&
+    typeof value !== "number" &&
+    !(value instanceof Date)
+  ) {
+    return false;
+  }
+
+  return !Number.isNaN(new Date(value).getTime());
+}
+
+const checkValueInIntervalRecursive = (
+  data: any,
+  propName: string,
+  startValue: number | Date,
+  endValue: number | Date,
+): boolean => {
+  if (data === null || data === undefined) {
+    return false;
+  }
+
+  const propPath = propName.split(".");
+  let current = data;
+
+  for (const segment of propPath) {
+    if (current && typeof current === "object" && segment in current) {
+      current = current[segment];
+    } else {
+      return false;
+    }
+  }
+
+  if (typeof current === "number") {
+    if (typeof startValue === "number" && typeof endValue === "number") {
+      if (startValue <= current && current <= endValue) {
+        return true;
+      }
+    }
+  } else if (isValidDateValue(current)) {
+    const date = new Date(current);
+    if (startValue instanceof Date && endValue instanceof Date) {
+      if (startValue <= date && date <= endValue) {
+        return true;
+      }
+    }
+  } else {
+    return false;
+  }
+
+  if (Array.isArray(data)) {
+    return data.some((item) =>
+      checkValueInIntervalRecursive(item, propName, startValue, endValue),
+    );
+  }
+
+  if (typeof data === "object") {
+    return Object.entries(data).some(([_key, value]) =>
+      checkValueInIntervalRecursive(value, propName, startValue, endValue),
+    );
+  }
+
+  return false;
+};
+
+export default checkValueInIntervalRecursive;

package/src/helpers/datas/dataBuilder.ts

@@ -1,6 +1,6 @@
-import type { Resource } from "@src/component";
+import type { UnknownResource } from "@src/component";
 
-export const recusiveRemovePath = (obj: Resource, pathArray: string[]) => {
+export const recusiveRemovePath = (obj: UnknownResource, pathArray: string[]) => {
   if (!obj || pathArray.length === 0) return;
   const key = pathArray.shift();
 
@@ -14,11 +14,11 @@ export const recusiveRemovePath = (obj: Resource, pathArray: string[]) => {
 };
 
 export const dataBuilder = (
-  resource: Resource,
+  resource: UnknownResource,
   pathToRemove: string[] = [],
   replacements: object = {},
   removeThenReplace = false,
-): Resource => {
+): UnknownResource => {
   const clone = structuredClone(resource);
 
   if (!removeThenReplace) {

package/src/helpers/datas/filterGenerator.ts

@@ -1,4 +1,6 @@
 const filterGenerator = (objects: { [key: string]: any }[], field: string) => {
+  const seen = new Map<string, boolean>();
+
   return objects
     .flatMap((obj) => {
       if (obj[field]) {
@@ -13,17 +15,18 @@ const filterGenerator = (objects: { [key: string]: any }[], field: string) => {
           value: obj[field]?.["@id"] || obj[field],
         };
       }
-      return;
+      return {
+        label: false,
+        value: false,
+      };
     })
-    .filter(
-      (value, index, self) =>
-        value?.label &&
-        value?.value &&
-        index ===
-          self.findIndex(
-            (t) => t?.label === value?.label && t?.value === value?.value,
-          ),
-    );
+    .filter((value) => {
+      if (!value?.label || !value?.value) return false;
+      const key = `${value.label}|${value.value}`;
+      if (seen.has(key)) return false;
+      seen.set(key, true);
+      return true;
+    });
 };
 
 export default filterGenerator;

package/src/helpers/datas/filterObjectByDateAfter.ts

@@ -1,4 +1,4 @@
-import type { Resource } from "@src/component";
+import type { UnknownResource } from "@src/component";
 
 function isValidDateValue(value: unknown): value is string | number | Date {
   return !Number.isNaN(new Date((value as Date)).getTime());
@@ -53,10 +53,10 @@ const checkDateIsAfterRecursive = (
 };
 
 const filterObjectByDateAfter = (
-  array: Resource[],
+  array: UnknownResource[],
   propName: string,
   thresholdDateString: string
-): Resource[] => {
+): UnknownResource[] => {
   if (
     !propName ||
     !thresholdDateString ||

package/src/helpers/datas/filterObjectByDateInterval.ts

@@ -0,0 +1,44 @@
+import type { UnknownResource } from "@src/component";
+import checkValueInIntervalRecursive from "@src/helpers/datas/checkValueInIntervalRecursive";
+
+/**
+ * Filters an array of Resource objects based on whether a specific date/number property
+ * falls within a given interval string (e.g., "2023-01-01/2023-01-31" or "3/6").
+ * Checks the property recursively within nested objects and arrays.
+ */
+const filterObjectByDateInterval = (
+  array: UnknownResource[],
+  propName: string,
+  interval: string,
+): UnknownResource[] => {
+  if (!propName || !interval || typeof interval !== "string") {
+    return array;
+  }
+
+  const [startStr, endStr] = interval.split("/");
+  if (!startStr) {
+    return array;
+  }
+
+  const startDate = new Date(startStr);
+
+  const endDate = new Date(endStr ?? startStr);
+
+  if (Number.isNaN(startDate.getTime()) || Number.isNaN(endDate.getTime())) {
+    console.warn(`Invalid date interval provided: ${interval}`);
+    return array;
+  }
+
+  endDate.setHours(23, 59, 59, 999);
+
+  if (startDate > endDate) {
+    console.warn(`Start date is after end date in interval: ${interval}`);
+    return array;
+  }
+
+  return array.filter((obj) =>
+    checkValueInIntervalRecursive(obj, propName, startDate, endDate),
+  );
+};
+
+export default filterObjectByDateInterval;

package/src/helpers/datas/filterObjectById.ts

@@ -1,17 +1,18 @@
-import type { Resource } from "@src/component";
+import type { UnknownResource } from "@src/component";
 
 const filterObjectById = (
-  array: Resource[],
+  array: UnknownResource[],
   propName: string,
-  targetId: string
-): Resource[] => {
+  targetId: string,
+): UnknownResource[] => {
   if (!propName || !targetId) {
     return array;
   }
 
+  const propPath = propName.split(".");
+
   return array.filter((obj) => {
     let current = obj;
-    const propPath = propName.split(".");
 
     for (const segment of propPath) {
       if (current && typeof current === "object" && segment in current) {
@@ -43,7 +44,7 @@ const filterObjectById = (
           typeof item === "object" &&
           item !== null &&
           "@id" in item &&
-          item["@id"] === targetId
+          item["@id"] === targetId,
       );
     }
 

package/src/helpers/datas/filterObjectByInterval.ts

@@ -1,115 +1,11 @@
-import type { Resource } from "@src/component";
-
-
-function isValidDateValue(value: unknown): value is string | number | Date {
- if (
-   typeof value !== "string" &&
-   typeof value !== "number" &&
-   !(value instanceof Date)
- ) {
-   return false;
- }
-
- return !Number.isNaN(new Date(value).getTime());
-}
-const checkValueInIntervalRecursive = (
-  data: any,
-  propName: string,
-  startValue: number | Date,
-  endValue: number | Date
-): boolean => {
-  if (data === null || data === undefined) {
-    return false;
-  }
-
-  const propPath = propName.split(".");
-  let current = data;
-
-  for (const segment of propPath) {
-    if (current && typeof current === "object" && segment in current) {
-      current = current[segment];
-    } else {
-      return false;
-    }
-  }
-
-  if (typeof current === "number") {
-    if (typeof startValue === "number" && typeof endValue === "number") {
-      if (startValue <= current && current <= endValue) {
-        return true;
-      }
-    }
-  } else if (isValidDateValue(current)) {
-    const date = new Date(current);
-    if (startValue instanceof Date && endValue instanceof Date) {
-      if (startValue <= date && date <= endValue) {
-        return true;
-      }
-    }
-  } else {
-    return false;
-  }
-
-  if (Array.isArray(data)) {
-    return data.some((item) =>
-      checkValueInIntervalRecursive(item, propName, startValue, endValue)
-    );
-  }
-
-  if (typeof data === "object") {
-    return Object.entries(data).some(([key, value]) =>
-      checkValueInIntervalRecursive(value, propName, startValue, endValue)
-    );
-  }
-
-  return false;
-};
-
-/**
- * Filters an array of Resource objects based on whether a specific date/number property
- * falls within a given interval string (e.g., "2023-01-01/2023-01-31" or "3/6").
- * Checks the property recursively within nested objects and arrays.
- */
-const filterObjectByDateInterval = (
-  array: Resource[],
-  propName: string,
-  interval: string
-): Resource[] => {
-  if (!propName || !interval || typeof interval !== "string") {
-    return array;
-  }
-
-  const [startStr, endStr] = interval.split("/");
-  if (!startStr) {
-    return array;
-  }
-
-  const startDate = new Date(startStr);
-
-  const endDate = new Date(endStr ?? startStr);
-
-  if (Number.isNaN(startDate.getTime()) || Number.isNaN(endDate.getTime())) {
-    console.warn(`Invalid date interval provided: ${interval}`);
-    return array;
-  }
-
-  endDate.setHours(23, 59, 59, 999);
-
-  if (startDate > endDate) {
-    console.warn(`Start date is after end date in interval: ${interval}`);
-    return array;
-  }
-
-  return array.filter((obj) =>
-    checkValueInIntervalRecursive(obj, propName, startDate, endDate)
-  );
-};
+import type { UnknownResource } from "@src/component";
+import checkValueInIntervalRecursive from "@src/helpers/datas/checkValueInIntervalRecursive";
 
 const filterObjectByInterval = (
-  array: Resource[],
+  array: UnknownResource[],
   propName: string,
-  interval: string
-): Resource[] => {
+  interval: string,
+): UnknownResource[] => {
   if (!propName || !interval || typeof interval !== "string") {
     return array;
   }
@@ -126,7 +22,7 @@ const filterObjectByInterval = (
   }
 
   return array.filter((obj) =>
-    checkValueInIntervalRecursive(obj, propName, startStr, endStr)
+    checkValueInIntervalRecursive(obj, propName, startStr, endStr),
   );
 };
 

package/src/helpers/datas/filterObjectByNamedValue.ts

@@ -1,9 +1,9 @@
-import type { Resource } from "@src/component";
+import type { UnknownResource } from "@src/component";
 
 const calculatePertinenceScoreRecursive = (
   data: any,
   lowerCaseString: string,
-  isTargetProperty: boolean
+  isTargetProperty: boolean,
 ): number => {
   if (data === null || data === undefined) {
     return 0;
@@ -18,7 +18,7 @@ const calculatePertinenceScoreRecursive = (
 
     const escapedString = lowerCaseString.replace(
       /[.*+?^${}()|[\]\\]/g,
-      "\\$&"
+      "\\$&",
     );
 
     const wholeWordRegex = new RegExp(`\\b${escapedString}\\b`);
@@ -40,8 +40,8 @@ const calculatePertinenceScoreRecursive = (
         calculatePertinenceScoreRecursive(
           item,
           lowerCaseString,
-          isTargetProperty
-        )
+          isTargetProperty,
+        ),
       );
       if (maxScore === 2) break;
     }
@@ -55,8 +55,8 @@ const calculatePertinenceScoreRecursive = (
       calculatePertinenceScoreRecursive(
         value,
         lowerCaseString,
-        isTargetProperty
-      )
+        isTargetProperty,
+      ),
     );
     if (maxScore === 2) break;
   }
@@ -64,40 +64,42 @@ const calculatePertinenceScoreRecursive = (
 };
 
 const filterObjectByNamedValue = (
-  array: Resource[],
+  array: UnknownResource[],
   propName: string,
-  searchString: string
-): Resource[] => {
+  searchString: string,
+): UnknownResource[] => {
   if (!propName || !searchString || searchString.trim() === "") {
     return array;
   }
 
   const lowerCaseString = searchString.toLowerCase();
-
-  const scoredObjects = array.map((obj) => {
-    let current: any = obj;
-    const propPath = propName.split(".");
-    for (const segment of propPath) {
-      if (current && typeof current === "object" && segment in current) {
-        current = current[segment];
-      } else {
-        current = null;
-        break;
+  const propPath = propName.split(".");
+
+  return array
+    .map((obj) => {
+      let current: any = obj;
+      for (const segment of propPath) {
+        if (current && typeof current === "object" && segment in current) {
+          current = current[segment];
+        } else {
+          current = null;
+          break;
+        }
       }
-    }
-
-    let score = 0;
-    if (current) {
-      score = calculatePertinenceScoreRecursive(current, lowerCaseString, true);
-    }
-    return { obj, score };
-  });
 
-  const filteredObjects = scoredObjects.filter((item) => item.score > 0);
-
-  filteredObjects.sort((a, b) => b.score - a.score);
-
-  return filteredObjects.map((item) => item.obj);
+      let score = 0;
+      if (current) {
+        score = calculatePertinenceScoreRecursive(
+          current,
+          lowerCaseString,
+          true,
+        );
+      }
+      return { obj, score };
+    })
+    .filter((item) => item.score > 0)
+    .sort((a, b) => b.score - a.score)
+    .map((item) => item.obj);
 };
 
 export default filterObjectByNamedValue;

package/src/helpers/datas/filterObjectByType.ts

@@ -1,9 +1,9 @@
-import type { Resource } from "@src/component";
+import type { UnknownResource } from "@src/component";
 
 const filterObjectByType = (
-  array: Resource[],
+  array: UnknownResource[],
   targetType: string
-): Resource[] => {
+): UnknownResource[] => {
   if (!targetType) {
     return array;
   }

package/src/helpers/datas/filterObjectByValue.ts

@@ -1,9 +1,9 @@
-import type { Resource } from "@src/component";
+import type { UnknownResource } from "@src/component";
 
 const calculatePertinenceScore = (
   data: any,
   lowerCaseString: string,
-  key?: string
+  key?: string,
 ): number => {
   if (data === null || data === undefined) {
     return 0;
@@ -14,7 +14,7 @@ const calculatePertinenceScore = (
 
     const escapedString = lowerCaseString.replace(
       /[.*+?^${}()|[\]\\]/g,
-      "\\$&"
+      "\\$&",
     );
 
     const wholeWordRegex = new RegExp(`\\b${escapedString}\\b`);
@@ -41,7 +41,7 @@ const calculatePertinenceScore = (
     for (const item of data) {
       maxScore = Math.max(
         maxScore,
-        calculatePertinenceScore(item, lowerCaseString)
+        calculatePertinenceScore(item, lowerCaseString),
       );
       if (maxScore === 4) break;
     }
@@ -52,30 +52,31 @@ const calculatePertinenceScore = (
   for (const [currentKey, value] of Object.entries(data)) {
     maxScore = Math.max(
       maxScore,
-      calculatePertinenceScore(value, lowerCaseString, currentKey)
+      calculatePertinenceScore(value, lowerCaseString, currentKey),
     );
     if (maxScore === 4) break;
   }
   return maxScore;
 };
 
-const filterObjectByValue = (array: Resource[], searchString: string): any[] => {
+const filterObjectByValue = (
+  array: UnknownResource[],
+  searchString: string,
+): UnknownResource[] => {
   if (!searchString || searchString.trim() === "") {
     return array;
   }
 
   const lowerCaseString = searchString.toLowerCase();
 
-  const scoredObjects = array.map((obj) => ({
-    obj,
-    score: calculatePertinenceScore(obj, lowerCaseString),
-  }));
-
-  const filteredObjects = scoredObjects.filter((item) => item.score > 0);
-
-  filteredObjects.sort((a, b) => b.score - a.score);
-
-  return filteredObjects.map((item) => item.obj);
+  return array
+    .map((obj) => ({
+      obj,
+      score: calculatePertinenceScore(obj, lowerCaseString),
+    }))
+    .filter((item) => item.score > 0)
+    .sort((a, b) => b.score - a.score)
+    .map((item) => item.obj);
 };
 
 export default filterObjectByValue;

package/src/helpers/datas/sort.ts

@@ -1,10 +1,10 @@
 const getValueFromAnyKey = (obj: any, keys: string[]): any => {
   let value = obj;
-  for (let i = 0; i < keys.length; i++) {
-    if (value && keys[i] in value) {
-      value = value[keys[i]];
+  for (const key of keys) {
+    if (value && key in value) {
+      value = value[key];
     } else {
-      break;
+      return undefined;
     }
   }
   return value;
@@ -13,28 +13,55 @@ const getValueFromAnyKey = (obj: any, keys: string[]): any => {
 type Sort = (arr: any[], k: string | string[], order?: "asc" | "desc") => any[];
 
 const sort: Sort = (arr, k, order = "asc") => {
-  return arr.sort((a, b) => {
-    let aN = a;
-    let bN = b;
-    if (Array.isArray(k)) {
-      aN = getValueFromAnyKey(a, k);
-      bN = getValueFromAnyKey(b, k);
-    } else {
-      aN = a[k];
-      bN = b[k];
+  const keys = Array.isArray(k) ? k : [k];
+  const shouldReverse = order !== "asc";
+
+  const result = [...arr];
+
+  const getComparator = () => {
+    const sampleValue = getValueFromAnyKey(result[0], keys);
+
+    if (typeof sampleValue === "number") {
+      return (a: any, b: any) => {
+        const aN = getValueFromAnyKey(a, keys);
+        const bN = getValueFromAnyKey(b, keys);
+        if (aN == null) return bN == null ? 0 : 1;
+        if (bN == null) return -1;
+        return (aN as number) - (bN as number);
+      };
     }
-    let c = 0;
-    if (typeof aN === "number" && typeof bN === "number") {
-      c = aN - bN;
-    } else if (typeof aN === "string" && typeof bN === "string") {
-      c = aN.localeCompare(bN);
-    } else if (aN instanceof Date && bN instanceof Date) {
-      c = aN.getTime() - bN.getTime();
-    } else {
-      throw new TypeError(`Unsupported data type for key "${k}"`);
+
+    if (typeof sampleValue === "string") {
+      return (a: any, b: any) => {
+        const aN = getValueFromAnyKey(a, keys);
+        const bN = getValueFromAnyKey(b, keys);
+        if (aN == null) return bN == null ? 0 : 1;
+        if (bN == null) return -1;
+        return (aN as string).localeCompare(bN as string);
+      };
     }
-    return order === "asc" ? c : -c;
+
+    if (sampleValue instanceof Date) {
+      return (a: any, b: any) => {
+        const aN = getValueFromAnyKey(a, keys);
+        const bN = getValueFromAnyKey(b, keys);
+        if (aN == null) return bN == null ? 0 : 1;
+        if (bN == null) return -1;
+        return (aN as Date).getTime() - (bN as Date).getTime();
+      };
+    }
+
+    throw new TypeError(`Unsupported data type for key "${k}"`);
+  };
+
+  const comparator = getComparator();
+
+  result.sort((a, b) => {
+    const comparison = comparator(a, b);
+    return shouldReverse ? -comparison : comparison;
   });
+
+  return result;
 };
 
 export default sort;