@startinblox/components-ds4go 1.0.0

package/src/helpers/datas/dataBuilder.ts

@@ -0,0 +1,43 @@
+import type { Resource } from "@src/component";
+
+export const recusiveRemovePath = (obj: Resource, pathArray: string[]) => {
+  if (!obj || pathArray.length === 0) return;
+  const key = pathArray.shift();
+
+  if (key !== undefined) {
+    if (pathArray.length === 0) {
+      delete obj[key];
+    } else if (obj[key] && typeof obj[key] === "object") {
+      recusiveRemovePath(obj[key], pathArray);
+    }
+  }
+};
+
+export const dataBuilder = (
+  resource: Resource,
+  pathToRemove: string[] = [],
+  replacements: object = {},
+  removeThenReplace = false,
+): Resource => {
+  const clone = structuredClone(resource);
+
+  if (!removeThenReplace) {
+    for (const path of pathToRemove) {
+      const splittedPath = path.split(".");
+      recusiveRemovePath(clone, splittedPath);
+    }
+  }
+
+  for (const [key, value] of Object.entries(replacements)) {
+    clone[key] = value;
+  }
+
+  if (removeThenReplace) {
+    for (const path of pathToRemove) {
+      const splittedPath = path.split(".");
+      recusiveRemovePath(clone, splittedPath);
+    }
+  }
+
+  return clone;
+};

package/src/helpers/datas/filterGenerator.ts

@@ -0,0 +1,29 @@
+const filterGenerator = (objects: { [key: string]: any }[], field: string) => {
+  return objects
+    .flatMap((obj) => {
+      if (obj[field]) {
+        if (Array.isArray(obj[field])) {
+          return obj[field].map((v) => ({
+            label: v?.name || v,
+            value: v?.["@id"] || v,
+          }));
+        }
+        return {
+          label: obj[field]?.name || obj[field],
+          value: obj[field]?.["@id"] || obj[field],
+        };
+      }
+      return;
+    })
+    .filter(
+      (value, index, self) =>
+        value?.label &&
+        value?.value &&
+        index ===
+          self.findIndex(
+            (t) => t?.label === value?.label && t?.value === value?.value,
+          ),
+    );
+};
+
+export default filterGenerator;

package/src/helpers/datas/filterObjectByDateAfter.ts

@@ -0,0 +1,80 @@
+import type { Resource } from "@src/component";
+
+function isValidDateValue(value: unknown): value is string | number | Date {
+  return !Number.isNaN(new Date((value as Date)).getTime());
+}
+
+const checkDateIsAfterRecursive = (
+  data: any,
+  propName: string,
+  thresholdDate: 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 (isValidDateValue(current)) {
+    const date = new Date(current);
+
+    if (date > thresholdDate) {
+      return true;
+    }
+  } else {
+    return false;
+  }
+
+  if (Array.isArray(data)) {
+    return data.some((item) =>
+      checkDateIsAfterRecursive(item, propName, thresholdDate)
+    );
+  }
+
+  if (typeof data === "object") {
+    return Object.entries(data).some(([key, value]) => {
+      if (key === propName && isValidDateValue(value)) {
+        return false;
+      }
+      return checkDateIsAfterRecursive(value, propName, thresholdDate);
+    });
+  }
+
+  return false;
+};
+
+const filterObjectByDateAfter = (
+  array: Resource[],
+  propName: string,
+  thresholdDateString: string
+): Resource[] => {
+  if (
+    !propName ||
+    !thresholdDateString ||
+    typeof thresholdDateString !== "string"
+  ) {
+    return array;
+  }
+
+  const thresholdDate = new Date(thresholdDateString);
+
+  if (Number.isNaN(thresholdDate.getTime())) {
+    console.warn(`Invalid threshold date provided: ${thresholdDateString}`);
+    return array;
+  }
+
+  return array.filter((obj) =>
+    checkDateIsAfterRecursive(obj, propName, thresholdDate)
+  );
+};
+
+export default filterObjectByDateAfter;

package/src/helpers/datas/filterObjectById.ts

@@ -0,0 +1,54 @@
+import type { Resource } from "@src/component";
+
+const filterObjectById = (
+  array: Resource[],
+  propName: string,
+  targetId: string
+): Resource[] => {
+  if (!propName || !targetId) {
+    return array;
+  }
+
+  return array.filter((obj) => {
+    let current = obj;
+    const propPath = propName.split(".");
+
+    for (const segment of propPath) {
+      if (current && typeof current === "object" && segment in current) {
+        current = current[segment];
+      } else {
+        return false;
+      }
+    }
+
+    const propValue = current;
+
+    if (!propValue) {
+      return false;
+    }
+
+    if (
+      typeof propValue === "object" &&
+      !Array.isArray(propValue) &&
+      propValue !== null &&
+      "@id" in propValue &&
+      propValue["@id"] === targetId
+    ) {
+      return true;
+    }
+
+    if (Array.isArray(propValue)) {
+      return propValue.some(
+        (item) =>
+          typeof item === "object" &&
+          item !== null &&
+          "@id" in item &&
+          item["@id"] === targetId
+      );
+    }
+
+    return false;
+  });
+};
+
+export default filterObjectById;

package/src/helpers/datas/filterObjectByInterval.ts

@@ -0,0 +1,133 @@
+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)
+  );
+};
+
+const filterObjectByInterval = (
+  array: Resource[],
+  propName: string,
+  interval: string
+): Resource[] => {
+  if (!propName || !interval || typeof interval !== "string") {
+    return array;
+  }
+
+  const [startStr, endStr] = interval.split("/").map(Number);
+
+  if (Number.isNaN(startStr) || Number.isNaN(endStr)) {
+    return array;
+  }
+
+  if (startStr > endStr) {
+    console.warn(`Start number is after end number in interval: ${interval}`);
+    return array;
+  }
+
+  return array.filter((obj) =>
+    checkValueInIntervalRecursive(obj, propName, startStr, endStr)
+  );
+};
+
+export default filterObjectByInterval;

package/src/helpers/datas/filterObjectByNamedValue.ts

@@ -0,0 +1,103 @@
+import type { Resource } from "@src/component";
+
+const calculatePertinenceScoreRecursive = (
+  data: any,
+  lowerCaseString: string,
+  isTargetProperty: boolean
+): number => {
+  if (data === null || data === undefined) {
+    return 0;
+  }
+
+  if (typeof data !== "object") {
+    if (!isTargetProperty) {
+      return 0;
+    }
+
+    const valueString = String(data).toLowerCase();
+
+    const escapedString = lowerCaseString.replace(
+      /[.*+?^${}()|[\]\\]/g,
+      "\\$&"
+    );
+
+    const wholeWordRegex = new RegExp(`\\b${escapedString}\\b`);
+
+    let score = 0;
+    if (wholeWordRegex.test(valueString)) {
+      score = 2;
+    } else if (valueString.includes(lowerCaseString)) {
+      score = 1;
+    }
+    return score;
+  }
+
+  if (Array.isArray(data)) {
+    let maxScore = 0;
+    for (const item of data) {
+      maxScore = Math.max(
+        maxScore,
+        calculatePertinenceScoreRecursive(
+          item,
+          lowerCaseString,
+          isTargetProperty
+        )
+      );
+      if (maxScore === 2) break;
+    }
+    return maxScore;
+  }
+
+  let maxScore = 0;
+  for (const value of Object.values(data)) {
+    maxScore = Math.max(
+      maxScore,
+      calculatePertinenceScoreRecursive(
+        value,
+        lowerCaseString,
+        isTargetProperty
+      )
+    );
+    if (maxScore === 2) break;
+  }
+  return maxScore;
+};
+
+const filterObjectByNamedValue = (
+  array: Resource[],
+  propName: string,
+  searchString: string
+): Resource[] => {
+  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;
+      }
+    }
+
+    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);
+};
+
+export default filterObjectByNamedValue;

package/src/helpers/datas/filterObjectByType.ts

@@ -0,0 +1,30 @@
+import type { Resource } from "@src/component";
+
+const filterObjectByType = (
+  array: Resource[],
+  targetType: string
+): Resource[] => {
+  if (!targetType) {
+    return array;
+  }
+
+  return array.filter((obj) => {
+    const type = obj["@type"];
+
+    if (!type) {
+      return false;
+    }
+
+    if (typeof type === "string") {
+      return type === targetType;
+    }
+
+    if (Array.isArray(type)) {
+      return type.some((t) => t === targetType);
+    }
+
+    return false;
+  });
+};
+
+export default filterObjectByType;

package/src/helpers/datas/filterObjectByValue.ts

@@ -0,0 +1,81 @@
+import type { Resource } from "@src/component";
+
+const calculatePertinenceScore = (
+  data: any,
+  lowerCaseString: string,
+  key?: string
+): number => {
+  if (data === null || data === undefined) {
+    return 0;
+  }
+
+  if (typeof data !== "object") {
+    const valueString = String(data).toLowerCase();
+
+    const escapedString = lowerCaseString.replace(
+      /[.*+?^${}()|[\]\\]/g,
+      "\\$&"
+    );
+
+    const wholeWordRegex = new RegExp(`\\b${escapedString}\\b`);
+
+    let score = 0;
+    if (wholeWordRegex.test(valueString)) {
+      if (key === "name" || key === "title") {
+        score = 4;
+      } else {
+        score = 3;
+      }
+    } else if (valueString.includes(lowerCaseString)) {
+      if (key === "name" || key === "title") {
+        score = 2;
+      } else {
+        score = 1;
+      }
+    }
+    return score;
+  }
+
+  if (Array.isArray(data)) {
+    let maxScore = 0;
+    for (const item of data) {
+      maxScore = Math.max(
+        maxScore,
+        calculatePertinenceScore(item, lowerCaseString)
+      );
+      if (maxScore === 4) break;
+    }
+    return maxScore;
+  }
+
+  let maxScore = 0;
+  for (const [currentKey, value] of Object.entries(data)) {
+    maxScore = Math.max(
+      maxScore,
+      calculatePertinenceScore(value, lowerCaseString, currentKey)
+    );
+    if (maxScore === 4) break;
+  }
+  return maxScore;
+};
+
+const filterObjectByValue = (array: Resource[], searchString: string): any[] => {
+  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);
+};
+
+export default filterObjectByValue;

package/src/helpers/datas/sort.ts

@@ -0,0 +1,40 @@
+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]];
+    } else {
+      break;
+    }
+  }
+  return value;
+};
+
+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];
+    }
+    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}"`);
+    }
+    return order === "asc" ? c : -c;
+  });
+};
+
+export default sort;

package/src/helpers/i18n/configureLocalization.ts

@@ -0,0 +1,17 @@
+import { configureLocalization } from "@lit/localize";
+import { sourceLocale, targetLocales } from "@src/generated/locale-codes.js";
+
+const langs = import.meta.glob("../../generated/locales/**/*.ts", { eager: true });
+
+const localizedTemplates: Map<string, any> = new Map(
+  targetLocales.map((locale) => [
+    locale,
+    langs[`../../generated/locales/${locale}.ts`],
+  ]),
+);
+
+export const { getLocale, setLocale } = configureLocalization({
+  sourceLocale,
+  targetLocales,
+  loadLocale: async (locale) => localizedTemplates.get(locale),
+});

package/src/helpers/index.ts

@@ -0,0 +1,43 @@
+import { ComponentObjectHandler } from "@helpers/components/componentObjectHandler";
+import { ComponentObjectsHandler } from "@helpers/components/componentObjectsHandler";
+// import dspComponent from "@helpers/components/dspComponent";
+import OrbitComponent from "@helpers/components/orbitComponent";
+import setupCacheInvalidation from "@helpers/components/setupCacheInvalidation";
+import setupCacheOnResourceReady from "@helpers/components/setupCacheOnResourceReady";
+import setupComponentSubscriptions from "@helpers/components/setupComponentSubscriptions";
+import setupOnSaveReset from "@helpers/components/setupOnSaveReset";
+import filterGenerator from "@helpers/datas/filterGenerator";
+import filterObjectByDateAfter from "@helpers/datas/filterObjectByDateAfter";
+import filterObjectById from "@helpers/datas/filterObjectById";
+import filterObjectByInterval from "@helpers/datas/filterObjectByInterval";
+import filterObjectByNamedValue from "@helpers/datas/filterObjectByNamedValue";
+import filterObjectByType from "@helpers/datas/filterObjectByType";
+import filterObjectByValue from "@helpers/datas/filterObjectByValue";
+import sort from "@helpers/datas/sort";
+import formatDate from "@helpers/ui/formatDate";
+import requestNavigation from "@helpers/utils/requestNavigation";
+import uniq from "@helpers/utils/uniq";
+import CLIENT_CONTEXT from "@src/context.json";
+
+export {
+  // dspComponent,
+  CLIENT_CONTEXT,
+  filterGenerator,
+  filterObjectByDateAfter,
+  filterObjectById,
+  filterObjectByInterval,
+  filterObjectByNamedValue,
+  filterObjectByValue,
+  filterObjectByType,
+  formatDate,
+  ComponentObjectHandler,
+  ComponentObjectsHandler,
+  OrbitComponent,
+  requestNavigation,
+  setupCacheInvalidation,
+  setupCacheOnResourceReady,
+  setupComponentSubscriptions,
+  setupOnSaveReset,
+  sort,
+  uniq,
+};