@empathyco/x-components 3.0.0-alpha.26 → 3.0.0-alpha.260

package/js/utils/array.js

@@ -25,7 +25,7 @@ function isArrayEmpty(array) {
  * @public
  */
 function arrayToObject(array, key) {
-    return array.reduce(function (accumulator, current) {
+    return array.reduce((accumulator, current) => {
         if (key) {
             accumulator[current[key]] = current;
         }
@@ -46,8 +46,8 @@ function arrayToObject(array, key) {
  * @public
  */
 function groupItemsBy(array, groupBy) {
-    return array.reduce(function (accumulator, current, index) {
-        var keyValue = groupBy(current, index);
+    return array.reduce((accumulator, current, index) => {
+        const keyValue = groupBy(current, index);
         if (!accumulator[keyValue]) {
             accumulator[keyValue] = [];
         }
@@ -56,13 +56,13 @@ function groupItemsBy(array, groupBy) {
     }, {});
 }
 /**
- * Filters an array with all elements that pass the test implemented by the provided filter
- * function. It also does it recursively if the property accessed, whose name is the parameter
- * childrenKey, to the current iteration in an array.
+ * Filters an array with all elements that pass the test implemented by the given filter
+ * function. If an item has another list of items in the `childrenKey` property it recursively
+ * filters that new list, adding it to the returned one.
  *
  * @param array - Array to be filtered.
- * @param filter - Predicate function to test each element of the array. It should return true
- * to keep the element; or false otherwise.
+ * @param condition - Predicate function to test each element of the array. It should return `true`
+ * to keep the element; or `false` otherwise.
  * @param childrenKey - Property name within the array used to perform a recursive call.
  *
  * @example
@@ -130,70 +130,57 @@ function groupItemsBy(array, groupBy) {
  *    ]
  * ```
  *
- * @returns A new array with the elements that pass the test, or an empty array if no one
+ * @returns A new array with the elements that pass the condition, or an empty array if no one
  * pass the test.
  *
  * @public
  */
-function deepFilter(array, filter, childrenKey) {
-    var filterArray = function (currentArray, initialArray) {
-        if (initialArray === void 0) { initialArray = []; }
-        return currentArray.reduce(function (result, currentItem) {
-            if (filter(currentItem)) {
-                result.push(currentItem);
-                filterArray(currentItem[childrenKey], result);
-            }
-            return result;
-        }, initialArray);
-    };
-    return filterArray(array);
+function deepFilter(array, condition, childrenKey) {
+    return array.reduce(function filter(filteredArray, item) {
+        if (condition(item)) {
+            filteredArray.push(item);
+            item[childrenKey]?.reduce(filter, filteredArray);
+        }
+        return filteredArray;
+    }, []);
 }
 /**
- * Flat an ArrayType[] recursively using the childrenKey passed as parameter to access to his nested
- * child which is also ArrayType[].
+ * Flat an `Item[]` deeply using the given `childrenKey` to access to his children.
  *
- * @param array - ArrayType[] which each ArrayType has a property childrenKey which value is also
- * an ArrayType[].
- * @param childrenKey - Key used to access to each ArrayType[childrenKey] value which is also
- * an ArrayType[].
+ * @param array - The list of items to flat. Each item may have another list of items of
+ * the same type to flat.
+ * @param childrenKey - Property name where each of the items of the given array may have another
+ * list of items to be flattened.
  *
- * @returns ArrayType[] with all the nested ArrayType, including the nested ones, at the same depth
- * level.
+ * @returns A flat list with all the found items.
  *
  * @public
  */
 function deepFlat(array, childrenKey) {
-    /**
-     * Flats an array recursively. In each iteration:
-     * - If the currentItem is an array, flatArray is used to reduce it. So, the order of the
-     * flatArray arguments defined is important. This happens when the function is called passing an
-     * array as the second parameter.
-     * - If not, the item is pushed to the resultantArray.
-     * - Finally, flatArray function is called again with the currentItem children and the process
-     * starts again.
-     *
-     * It's the main function of the parent. See the description above
-     * for further information.
-     *
-     * @param resultantArray - Flattened array.
-     * @param currentItem - ArrayType object.
-     *
-     * @returns Flattened ArrayType[].
-     *
-     * @internal
-     */
-    function flatArray(resultantArray, currentItem) {
-        if (!currentItem) {
-            return resultantArray;
-        }
-        if (Array.isArray(currentItem)) {
-            return currentItem.reduce(flatArray, resultantArray);
-        }
-        resultantArray.push(currentItem);
-        return flatArray(resultantArray, currentItem[childrenKey]);
-    }
-    return flatArray([], array);
+    return array.reduce(function flat(flattenedArray, item) {
+        flattenedArray.push(item);
+        item[childrenKey]?.reduce(flat, flattenedArray);
+        return flattenedArray;
+    }, []);
+}
+/**
+ * Creates an Emitter filter function to compare two arrays and filter those that are equal.
+ *
+ * @param comparator - String with the name of the field of the arrays items to compare, or function
+ * to compare items directly.
+ * @returns The comparator function that receives two arrays to compare them.
+ *
+ * @internal
+ */
+function createEmitterArrayFilter(comparator) {
+    const comparatorFn = typeof comparator === 'function'
+        ? comparator
+        : (newItem, oldItem) => newItem[comparator] === oldItem[comparator];
+    return function (newCollection, oldCollection) {
+        return (newCollection.length !== oldCollection.length ||
+            newCollection.some(newItem => !oldCollection.find(oldItem => comparatorFn(newItem, oldItem))));
+    };
 }
 
-export { arrayToObject, deepFilter, deepFlat, groupItemsBy, isArrayEmpty };
+export { arrayToObject, createEmitterArrayFilter, deepFilter, deepFlat, groupItemsBy, isArrayEmpty };
 //# sourceMappingURL=array.js.map

package/js/utils/array.js.map

@@ -1 +1 @@
-{"version":3,"file":"array.js","sources":["../../../src/utils/array.ts"],"sourcesContent":["import { PropsWithType } from './types';\n\n/**\n * Returns if the given array is `null`, `undefined`, or has no elements.\n *\n * @param array - The array to check if it is empty.\n * @returns `true` if the array is `null`, `undefined`, or has no elements. `false` otherwise.\n * @public\n */\nexport function isArrayEmpty(array: unknown[] | undefined | null): array is undefined | null | [] {\n  return array == null || array.length === 0;\n}\n\n/**\n * Reduce an array of strings to an object which properties names are the value of each string,\n * and the value under that property are also the string.\n *\n * @param array - Array of strings that will be used to create the object.\n *\n * @returns New object which properties object[key] contains object of each iteration in the\n * array.\n *\n * @example Converting an array to an object:\n *         arrayToObject(['a', 'b', 'c']) === \\{a: 'a', b: 'b', c: 'c'\\}\n *\n * @public\n */\nexport function arrayToObject(array: string[]): Record<string, string>;\n/**\n * Reduce an array of objects to an object which properties names are the value of each object[key],\n * and the value under that property are each object. 'key' is the the parameter passed to this\n * function.\n *\n * @param array - Array of objects that contains objects which have object[key] string as a property\n * value.\n * @param key - Key used to access to each object[key] value, used for each property name in the new\n * object.\n *\n * @returns New object which properties object[key] contains object of each iteration in the array.\n *\n * @public\n */\nexport function arrayToObject<ArrayType, KeyType extends string | number>(\n  array: ArrayType[],\n  key: PropsWithType<ArrayType, KeyType>\n): Record<string, ArrayType>;\n/**\n * Reduce an array to an object. The type of the object returned depends on the type of the params.\n * If the 'key' is passed then the function returns an object which properties names are the value\n * of each object[key] and the value under that property are each object.\n * If the 'key' is not passed then the function returns an object which properties names are each\n * array item, and the value is also the array item.\n *\n * @param array - Array from which to create an object.\n * @param key - Key used to access to each object[key] value, used for each property name in the\n * new object.\n *\n * @returns New object which properties object[key] contains each item in the array and the key is\n * either the item of the array or a property of each item designated by 'key' param.\n *\n * @public\n */\nexport function arrayToObject<ArrayType, KeyType extends string | number>(\n  array: ArrayType[],\n  key?: PropsWithType<ArrayType, KeyType>\n): Record<string, ArrayType> {\n  return array.reduce<Record<string, ArrayType>>((accumulator, current) => {\n    if (key) {\n      accumulator[current[key] as unknown as string] = current;\n    } else if (typeof current === 'string') {\n      accumulator[current] = current;\n    }\n    return accumulator;\n  }, {});\n}\n\n/**\n * Groups the array items based on the provided `groupBy` function.\n *\n * @param array - The array to iterate, grouping its items in different arrays based on the\n * `groupBy` function.\n * @param groupBy - A function to determine the group name of a single item.\n * @returns The items grouped in a dictionary.\n *\n * @public\n */\nexport function groupItemsBy<ArrayType, ReturnType extends string | number>(\n  array: ArrayType[],\n  groupBy: (item: ArrayType, index: number) => ReturnType\n): Record<ReturnType, ArrayType[]> {\n  return array.reduce<Record<ReturnType, ArrayType[]>>((accumulator, current, index) => {\n    const keyValue = groupBy(current, index);\n    if (!accumulator[keyValue]) {\n      accumulator[keyValue] = [];\n    }\n    accumulator[keyValue].push(current);\n    return accumulator;\n  }, {} as Record<ReturnType, ArrayType[]>);\n}\n\n/**\n * Filters an array with all elements that pass the test implemented by the provided filter\n * function. It also does it recursively if the property accessed, whose name is the parameter\n * childrenKey, to the current iteration in an array.\n *\n * @param array - Array to be filtered.\n * @param filter - Predicate function to test each element of the array. It should return true\n * to keep the element; or false otherwise.\n * @param childrenKey - Property name within the array used to perform a recursive call.\n *\n * @example\n * Input - Output example\n *\n * ```\n * const hierarchicalFilters: Filter[] = [\n *   {\n *     id: 'filter1'\n *     selected: true,\n *     children: [\n *       {\n *         id: 'filter1-1'\n *         selected: true,\n *         children: []\n *       },\n *       {\n *         id: 'filter1-2'\n *         selected: false,\n *         children: []\n *       }\n *     ]\n *   },\n *   {\n *     id: 'filter2',\n *     selected: false,\n *     children: [\n *      {\n *        id: 'filter2-1',\n *        selected: true // not should happen\n *      }\n *     ]\n *   }\n * ]\n *\n *  const filteredArray: Filter[] = deepFilterArray(\n *    hierarchicalFilters,\n *    filter => filter.selected,\n *    'children'\n *  )\n *\n *  /*\n *    filteredArray = [\n *      {\n *        id: 'filter1'\n *        selected: true,\n *        children: [\n *          {\n *            id: 'filter1-1'\n *            selected: true,\n *            children: []\n *          },\n *          {\n *            id: 'filter1-2'\n *            selected: false,\n *            children: []\n *          }\n *        ]\n *      },\n *      {\n *        id: 'filter1-1'\n *        selected: true,\n *        children: []\n *      }\n *    ]\n * ```\n *\n * @returns A new array with the elements that pass the test, or an empty array if no one\n * pass the test.\n *\n * @public\n */\nexport function deepFilter<ArrayType, Key extends PropsWithType<ArrayType, ArrayType[]>>(\n  array: ArrayType[],\n  filter: (item: ArrayType) => boolean,\n  childrenKey: Key\n): ArrayType[] {\n  const filterArray = function (\n    currentArray: ArrayType[],\n    initialArray: ArrayType[] = []\n  ): ArrayType[] {\n    return currentArray.reduce((result, currentItem) => {\n      if (filter(currentItem)) {\n        result.push(currentItem);\n        filterArray(currentItem[childrenKey], result);\n      }\n\n      return result;\n    }, initialArray);\n  };\n\n  return filterArray(array);\n}\n\n/**\n * Flat an ArrayType[] recursively using the childrenKey passed as parameter to access to his nested\n * child which is also ArrayType[].\n *\n * @param array - ArrayType[] which each ArrayType has a property childrenKey which value is also\n * an ArrayType[].\n * @param childrenKey - Key used to access to each ArrayType[childrenKey] value which is also\n * an ArrayType[].\n *\n * @returns ArrayType[] with all the nested ArrayType, including the nested ones, at the same depth\n * level.\n *\n * @public\n */\nexport function deepFlat<ArrayType, Key extends PropsWithType<ArrayType, ArrayType[] | undefined>>(\n  array: ArrayType[],\n  childrenKey: Key\n): ArrayType[] {\n  /**\n   * Flats an array recursively. In each iteration:\n   * - If the currentItem is an array, flatArray is used to reduce it. So, the order of the\n   * flatArray arguments defined is important. This happens when the function is called passing an\n   * array as the second parameter.\n   * - If not, the item is pushed to the resultantArray.\n   * - Finally, flatArray function is called again with the currentItem children and the process\n   * starts again.\n   *\n   * It's the main function of the parent. See the description above\n   * for further information.\n   *\n   * @param resultantArray - Flattened array.\n   * @param currentItem - ArrayType object.\n   *\n   * @returns Flattened ArrayType[].\n   *\n   * @internal\n   */\n  function flatArray(\n    resultantArray: ArrayType[],\n    currentItem: ArrayType | ArrayType[]\n  ): ArrayType[] {\n    if (!currentItem) {\n      return resultantArray;\n    }\n\n    if (Array.isArray(currentItem)) {\n      return currentItem.reduce(flatArray, resultantArray);\n    }\n    resultantArray.push(currentItem);\n    return flatArray(resultantArray, currentItem[childrenKey]);\n  }\n\n  return flatArray([], array);\n}\n"],"names":[],"mappings":"AAEA;;;;;;;SAOgB,YAAY,CAAC,KAAmC;IAC9D,OAAO,KAAK,IAAI,IAAI,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC;AAC7C,CAAC;AAmCD;;;;;;;;;;;;;;;;SAgBgB,aAAa,CAC3B,KAAkB,EAClB,GAAuC;IAEvC,OAAO,KAAK,CAAC,MAAM,CAA4B,UAAC,WAAW,EAAE,OAAO;QAClE,IAAI,GAAG,EAAE;YACP,WAAW,CAAC,OAAO,CAAC,GAAG,CAAsB,CAAC,GAAG,OAAO,CAAC;SAC1D;aAAM,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE;YACtC,WAAW,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;SAChC;QACD,OAAO,WAAW,CAAC;KACpB,EAAE,EAAE,CAAC,CAAC;AACT,CAAC;AAED;;;;;;;;;;SAUgB,YAAY,CAC1B,KAAkB,EAClB,OAAuD;IAEvD,OAAO,KAAK,CAAC,MAAM,CAAkC,UAAC,WAAW,EAAE,OAAO,EAAE,KAAK;QAC/E,IAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QACzC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,EAAE;YAC1B,WAAW,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;SAC5B;QACD,WAAW,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACpC,OAAO,WAAW,CAAC;KACpB,EAAE,EAAqC,CAAC,CAAC;AAC5C,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAgFgB,UAAU,CACxB,KAAkB,EAClB,MAAoC,EACpC,WAAgB;IAEhB,IAAM,WAAW,GAAG,UAClB,YAAyB,EACzB,YAA8B;QAA9B,6BAAA,EAAA,iBAA8B;QAE9B,OAAO,YAAY,CAAC,MAAM,CAAC,UAAC,MAAM,EAAE,WAAW;YAC7C,IAAI,MAAM,CAAC,WAAW,CAAC,EAAE;gBACvB,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;gBACzB,WAAW,CAAC,WAAW,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC,CAAC;aAC/C;YAED,OAAO,MAAM,CAAC;SACf,EAAE,YAAY,CAAC,CAAC;KAClB,CAAC;IAEF,OAAO,WAAW,CAAC,KAAK,CAAC,CAAC;AAC5B,CAAC;AAED;;;;;;;;;;;;;;SAcgB,QAAQ,CACtB,KAAkB,EAClB,WAAgB;;;;;;;;;;;;;;;;;;;;IAqBhB,SAAS,SAAS,CAChB,cAA2B,EAC3B,WAAoC;QAEpC,IAAI,CAAC,WAAW,EAAE;YAChB,OAAO,cAAc,CAAC;SACvB;QAED,IAAI,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE;YAC9B,OAAO,WAAW,CAAC,MAAM,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC;SACtD;QACD,cAAc,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QACjC,OAAO,SAAS,CAAC,cAAc,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC;KAC5D;IAED,OAAO,SAAS,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;AAC9B;;;;"}
+{"version":3,"file":"array.js","sources":["../../../src/utils/array.ts"],"sourcesContent":["import { PropsWithType } from './types';\n\n/**\n * Returns if the given array is `null`, `undefined`, or has no elements.\n *\n * @param array - The array to check if it is empty.\n * @returns `true` if the array is `null`, `undefined`, or has no elements. `false` otherwise.\n * @public\n */\nexport function isArrayEmpty(array: unknown[] | undefined | null): array is undefined | null | [] {\n  return array == null || array.length === 0;\n}\n\n/**\n * Reduce an array of strings to an object which properties names are the value of each string,\n * and the value under that property are also the string.\n *\n * @param array - Array of strings that will be used to create the object.\n *\n * @returns New object which properties object[key] contains object of each iteration in the\n * array.\n *\n * @example Converting an array to an object:\n *         arrayToObject(['a', 'b', 'c']) === \\{a: 'a', b: 'b', c: 'c'\\}\n *\n * @public\n */\nexport function arrayToObject(array: string[]): Record<string, string>;\n/**\n * Reduce an array of objects to an object which properties names are the value of each object[key],\n * and the value under that property are each object. 'key' is the the parameter passed to this\n * function.\n *\n * @param array - Array of objects that contains objects which have object[key] string as a property\n * value.\n * @param key - Key used to access to each object[key] value, used for each property name in the new\n * object.\n *\n * @returns New object which properties object[key] contains object of each iteration in the array.\n *\n * @public\n */\nexport function arrayToObject<ArrayType>(\n  array: ArrayType[],\n  key: PropsWithType<ArrayType, string | number>\n): Record<string, ArrayType>;\n/**\n * Reduce an array to an object. The type of the object returned depends on the type of the params.\n * If the 'key' is passed then the function returns an object which properties names are the value\n * of each object[key] and the value under that property are each object.\n * If the 'key' is not passed then the function returns an object which properties names are each\n * array item, and the value is also the array item.\n *\n * @param array - Array from which to create an object.\n * @param key - Key used to access to each object[key] value, used for each property name in the\n * new object.\n *\n * @returns New object which properties object[key] contains each item in the array and the key is\n * either the item of the array or a property of each item designated by 'key' param.\n *\n * @public\n */\nexport function arrayToObject<ArrayType>(\n  array: ArrayType[],\n  key?: PropsWithType<ArrayType, string | number>\n): Record<string, ArrayType> {\n  return array.reduce<Record<string, ArrayType>>((accumulator, current) => {\n    if (key) {\n      accumulator[current[key] as any] = current;\n    } else if (typeof current === 'string') {\n      accumulator[current] = current;\n    }\n    return accumulator;\n  }, {});\n}\n\n/**\n * Groups the array items based on the provided `groupBy` function.\n *\n * @param array - The array to iterate, grouping its items in different arrays based on the\n * `groupBy` function.\n * @param groupBy - A function to determine the group name of a single item.\n * @returns The items grouped in a dictionary.\n *\n * @public\n */\nexport function groupItemsBy<ArrayType, ReturnType extends string | number>(\n  array: ArrayType[],\n  groupBy: (item: ArrayType, index: number) => ReturnType\n): Record<ReturnType, ArrayType[]> {\n  return array.reduce<Record<ReturnType, ArrayType[]>>((accumulator, current, index) => {\n    const keyValue = groupBy(current, index);\n    if (!accumulator[keyValue]) {\n      accumulator[keyValue] = [];\n    }\n    accumulator[keyValue].push(current);\n    return accumulator;\n  }, {} as Record<ReturnType, ArrayType[]>);\n}\n\n/**\n * Filters an array with all elements that pass the test implemented by the given filter\n * function. If an item has another list of items in the `childrenKey` property it recursively\n * filters that new list, adding it to the returned one.\n *\n * @param array - Array to be filtered.\n * @param condition - Predicate function to test each element of the array. It should return `true`\n * to keep the element; or `false` otherwise.\n * @param childrenKey - Property name within the array used to perform a recursive call.\n *\n * @example\n * Input - Output example\n *\n * ```\n * const hierarchicalFilters: Filter[] = [\n *   {\n *     id: 'filter1'\n *     selected: true,\n *     children: [\n *       {\n *         id: 'filter1-1'\n *         selected: true,\n *         children: []\n *       },\n *       {\n *         id: 'filter1-2'\n *         selected: false,\n *         children: []\n *       }\n *     ]\n *   },\n *   {\n *     id: 'filter2',\n *     selected: false,\n *     children: [\n *      {\n *        id: 'filter2-1',\n *        selected: true // not should happen\n *      }\n *     ]\n *   }\n * ]\n *\n *  const filteredArray: Filter[] = deepFilterArray(\n *    hierarchicalFilters,\n *    filter => filter.selected,\n *    'children'\n *  )\n *\n *  /*\n *    filteredArray = [\n *      {\n *        id: 'filter1'\n *        selected: true,\n *        children: [\n *          {\n *            id: 'filter1-1'\n *            selected: true,\n *            children: []\n *          },\n *          {\n *            id: 'filter1-2'\n *            selected: false,\n *            children: []\n *          }\n *        ]\n *      },\n *      {\n *        id: 'filter1-1'\n *        selected: true,\n *        children: []\n *      }\n *    ]\n * ```\n *\n * @returns A new array with the elements that pass the condition, or an empty array if no one\n * pass the test.\n *\n * @public\n */\nexport function deepFilter<Item extends { [key in Key]?: Item[] }, Key extends keyof Item>(\n  array: Item[],\n  condition: (item: Item) => boolean,\n  childrenKey: Key\n): Item[] {\n  return array.reduce<Item[]>(function filter(filteredArray, item) {\n    if (condition(item)) {\n      filteredArray.push(item);\n      item[childrenKey]?.reduce(filter, filteredArray);\n    }\n    return filteredArray;\n  }, []);\n}\n\n/**\n * Flat an `Item[]` deeply using the given `childrenKey` to access to his children.\n *\n * @param array - The list of items to flat. Each item may have another list of items of\n * the same type to flat.\n * @param childrenKey - Property name where each of the items of the given array may have another\n * list of items to be flattened.\n *\n * @returns A flat list with all the found items.\n *\n * @public\n */\nexport function deepFlat<Item extends { [key in Key]?: Item[] }, Key extends keyof Item>(\n  array: Item[],\n  childrenKey: Key\n): Item[] {\n  return array.reduce<Item[]>(function flat(flattenedArray, item) {\n    flattenedArray.push(item);\n    item[childrenKey]?.reduce(flat, flattenedArray);\n    return flattenedArray;\n  }, []);\n}\n\n/**\n * Creates an Emitter filter function to compare two arrays and filter those that are equal.\n *\n * @param comparator - String with the name of the field of the arrays items to compare, or function\n * to compare items directly.\n * @returns The comparator function that receives two arrays to compare them.\n *\n * @internal\n */\nexport function createEmitterArrayFilter<T>(\n  comparator: keyof T | ((item1: T, item2: T) => boolean)\n): (newCollection: Array<T>, oldCollection: Array<T>) => boolean {\n  const comparatorFn =\n    typeof comparator === 'function'\n      ? comparator\n      : (newItem: T, oldItem: T) => newItem[comparator] === oldItem[comparator];\n  return function (newCollection: Array<T>, oldCollection: Array<T>): boolean {\n    return (\n      newCollection.length !== oldCollection.length ||\n      newCollection.some(newItem => !oldCollection.find(oldItem => comparatorFn(newItem, oldItem)))\n    );\n  };\n}\n"],"names":[],"mappings":"AAEA;;;;;;AAMG;AACG,SAAU,YAAY,CAAC,KAAmC,EAAA;IAC9D,OAAO,KAAK,IAAI,IAAI,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC;AAC7C,CAAC;AAmCD;;;;;;;;;;;;;;;AAeG;AACa,SAAA,aAAa,CAC3B,KAAkB,EAClB,GAA+C,EAAA;IAE/C,OAAO,KAAK,CAAC,MAAM,CAA4B,CAAC,WAAW,EAAE,OAAO,KAAI;AACtE,QAAA,IAAI,GAAG,EAAE;YACP,WAAW,CAAC,OAAO,CAAC,GAAG,CAAQ,CAAC,GAAG,OAAO,CAAC;AAC5C,SAAA;AAAM,aAAA,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE;AACtC,YAAA,WAAW,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;AAChC,SAAA;AACD,QAAA,OAAO,WAAW,CAAC;KACpB,EAAE,EAAE,CAAC,CAAC;AACT,CAAC;AAED;;;;;;;;;AASG;AACa,SAAA,YAAY,CAC1B,KAAkB,EAClB,OAAuD,EAAA;IAEvD,OAAO,KAAK,CAAC,MAAM,CAAkC,CAAC,WAAW,EAAE,OAAO,EAAE,KAAK,KAAI;QACnF,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;AACzC,QAAA,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,EAAE;AAC1B,YAAA,WAAW,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;AAC5B,SAAA;QACD,WAAW,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AACpC,QAAA,OAAO,WAAW,CAAC;KACpB,EAAE,EAAqC,CAAC,CAAC;AAC5C,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+EG;SACa,UAAU,CACxB,KAAa,EACb,SAAkC,EAClC,WAAgB,EAAA;IAEhB,OAAO,KAAK,CAAC,MAAM,CAAS,SAAS,MAAM,CAAC,aAAa,EAAE,IAAI,EAAA;AAC7D,QAAA,IAAI,SAAS,CAAC,IAAI,CAAC,EAAE;AACnB,YAAA,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACzB,IAAI,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;AAClD,SAAA;AACD,QAAA,OAAO,aAAa,CAAC;KACtB,EAAE,EAAE,CAAC,CAAC;AACT,CAAC;AAED;;;;;;;;;;;AAWG;AACa,SAAA,QAAQ,CACtB,KAAa,EACb,WAAgB,EAAA;IAEhB,OAAO,KAAK,CAAC,MAAM,CAAS,SAAS,IAAI,CAAC,cAAc,EAAE,IAAI,EAAA;AAC5D,QAAA,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC1B,IAAI,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC;AAChD,QAAA,OAAO,cAAc,CAAC;KACvB,EAAE,EAAE,CAAC,CAAC;AACT,CAAC;AAED;;;;;;;;AAQG;AACG,SAAU,wBAAwB,CACtC,UAAuD,EAAA;AAEvD,IAAA,MAAM,YAAY,GAChB,OAAO,UAAU,KAAK,UAAU;AAC9B,UAAE,UAAU;AACZ,UAAE,CAAC,OAAU,EAAE,OAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;IAC9E,OAAO,UAAU,aAAuB,EAAE,aAAuB,EAAA;AAC/D,QAAA,QACE,aAAa,CAAC,MAAM,KAAK,aAAa,CAAC,MAAM;YAC7C,aAAa,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,OAAO,IAAI,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAC7F;AACJ,KAAC,CAAC;AACJ;;;;"}

package/js/utils/cancellable-promise.js

@@ -5,7 +5,7 @@ import { noOp } from './function.js';
  *
  * @internal
  */
-var CancelSymbol = Symbol('cancelled-promise');
+const CancelSymbol = Symbol('cancelled-promise');
 /**
  * Util function that returns an object which contains a promise, result of Promise.race call
  * between the original one passed as parameter and another one, created within the function, used
@@ -27,16 +27,16 @@ var CancelSymbol = Symbol('cancelled-promise');
  * @internal
  */
 function cancellablePromise(promise, cancelCallback) {
-    var cancel = noOp;
-    var cancelPromise = new Promise(function (_, reject) {
-        cancel = function (payload) {
+    let cancel = noOp;
+    const cancelPromise = new Promise((_, reject) => {
+        cancel = payload => {
             reject(CancelSymbol);
-            cancelCallback === null || cancelCallback === void 0 ? void 0 : cancelCallback(payload);
+            cancelCallback?.(payload);
         };
     });
     return {
         promise: Promise.race([promise, cancelPromise]),
-        cancel: cancel
+        cancel
     };
 }
 

package/js/utils/cancellable-promise.js.map

@@ -1 +1 @@
-{"version":3,"file":"cancellable-promise.js","sources":["../../../src/utils/cancellable-promise.ts"],"sourcesContent":["import { noOp } from './function';\n/**\n * Symbol used to know if a promise is cancelled.\n *\n * @internal\n */\nexport const CancelSymbol = Symbol('cancelled-promise');\n/**\n * The type returned by the {@link cancellablePromise} function.\n *\n * @internal\n */\nexport interface CancellablePromiseFunction<T, K = unknown> {\n  /**\n   * The resultant promise that groups the original promise, passed as the first parameter, and the\n   * promise created in cancellablePromise, which rejects the resultant promise if called.\n   */\n  promise: Promise<T>;\n  /**\n   * Function to cancel the resultant promise. This function triggers the reject of the second\n   * promise of the promise race. The first parameter is the resultant promise rejection value.\n   */\n  cancel: (payload?: K) => void;\n}\n\n/**\n * Util function that returns an object which contains a promise, result of Promise.race call\n * between the original one passed as parameter and another one, created within the function, used\n * for reject in the resultant promise manually. If the cancel method is triggered, the\n * resultant promise is rejected.\n *\n * @remarks The promise function passed as first param executes its own async code ALWAYS although\n * it's cancelled or not. The payload of the resultant promise is the returned by the function that\n * ends first. So, the promise is not cancelled exactly. The parameter first passed to cancel is the\n * resultant promise rejection value.\n *\n * If you need to check if the promise is not being rejected with CancelSymbol (on purpose).\n * You should check the error type in the cancellable catch using the payload.\n *\n * @param promise - Original promise.\n * @param cancelCallback - Optional callback to be called on cancel.\n * @returns CancellablePromiseFunction {@link CancellablePromiseFunction}.\n *\n * @internal\n */\nexport function cancellablePromise<T, K = unknown>(\n  promise: Promise<T>,\n  cancelCallback?: (payload?: K) => void\n): CancellablePromiseFunction<T, K> {\n  let cancel: (payload?: K) => void = noOp;\n\n  const cancelPromise = new Promise<never>((_, reject) => {\n    cancel = payload => {\n      reject(CancelSymbol);\n      cancelCallback?.(payload);\n    };\n  });\n\n  return {\n    promise: Promise.race([promise, cancelPromise]),\n    cancel\n  };\n}\n"],"names":[],"mappings":";;AACA;;;;;IAKa,YAAY,GAAG,MAAM,CAAC,mBAAmB,EAAE;AAmBxD;;;;;;;;;;;;;;;;;;;;SAoBgB,kBAAkB,CAChC,OAAmB,EACnB,cAAsC;IAEtC,IAAI,MAAM,GAA0B,IAAI,CAAC;IAEzC,IAAM,aAAa,GAAG,IAAI,OAAO,CAAQ,UAAC,CAAC,EAAE,MAAM;QACjD,MAAM,GAAG,UAAA,OAAO;YACd,MAAM,CAAC,YAAY,CAAC,CAAC;YACrB,cAAc,aAAd,cAAc,uBAAd,cAAc,CAAG,OAAO,CAAC,CAAC;SAC3B,CAAC;KACH,CAAC,CAAC;IAEH,OAAO;QACL,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC;QAC/C,MAAM,QAAA;KACP,CAAC;AACJ;;;;"}
+{"version":3,"file":"cancellable-promise.js","sources":["../../../src/utils/cancellable-promise.ts"],"sourcesContent":["import { noOp } from './function';\n/**\n * Symbol used to know if a promise is cancelled.\n *\n * @internal\n */\nexport const CancelSymbol = Symbol('cancelled-promise');\n/**\n * The type returned by the {@link cancellablePromise} function.\n *\n * @internal\n */\nexport interface CancellablePromiseFunction<T, K = unknown> {\n  /**\n   * The resultant promise that groups the original promise, passed as the first parameter, and the\n   * promise created in cancellablePromise, which rejects the resultant promise if called.\n   */\n  promise: Promise<T>;\n  /**\n   * Function to cancel the resultant promise. This function triggers the reject of the second\n   * promise of the promise race. The first parameter is the resultant promise rejection value.\n   */\n  cancel: (payload?: K) => void;\n}\n\n/**\n * Util function that returns an object which contains a promise, result of Promise.race call\n * between the original one passed as parameter and another one, created within the function, used\n * for reject in the resultant promise manually. If the cancel method is triggered, the\n * resultant promise is rejected.\n *\n * @remarks The promise function passed as first param executes its own async code ALWAYS although\n * it's cancelled or not. The payload of the resultant promise is the returned by the function that\n * ends first. So, the promise is not cancelled exactly. The parameter first passed to cancel is the\n * resultant promise rejection value.\n *\n * If you need to check if the promise is not being rejected with CancelSymbol (on purpose).\n * You should check the error type in the cancellable catch using the payload.\n *\n * @param promise - Original promise.\n * @param cancelCallback - Optional callback to be called on cancel.\n * @returns CancellablePromiseFunction {@link CancellablePromiseFunction}.\n *\n * @internal\n */\nexport function cancellablePromise<T, K = unknown>(\n  promise: Promise<T>,\n  cancelCallback?: (payload?: K) => void\n): CancellablePromiseFunction<T, K> {\n  let cancel: (payload?: K) => void = noOp;\n\n  const cancelPromise = new Promise<never>((_, reject) => {\n    cancel = payload => {\n      reject(CancelSymbol);\n      cancelCallback?.(payload);\n    };\n  });\n\n  return {\n    promise: Promise.race([promise, cancelPromise]),\n    cancel\n  };\n}\n"],"names":[],"mappings":";;AACA;;;;AAIG;MACU,YAAY,GAAG,MAAM,CAAC,mBAAmB,EAAE;AAmBxD;;;;;;;;;;;;;;;;;;;AAmBG;AACa,SAAA,kBAAkB,CAChC,OAAmB,EACnB,cAAsC,EAAA;IAEtC,IAAI,MAAM,GAA0B,IAAI,CAAC;IAEzC,MAAM,aAAa,GAAG,IAAI,OAAO,CAAQ,CAAC,CAAC,EAAE,MAAM,KAAI;QACrD,MAAM,GAAG,OAAO,IAAG;YACjB,MAAM,CAAC,YAAY,CAAC,CAAC;AACrB,YAAA,cAAc,GAAG,OAAO,CAAC,CAAC;AAC5B,SAAC,CAAC;AACJ,KAAC,CAAC,CAAC;IAEH,OAAO;QACL,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC;QAC/C,MAAM;KACP,CAAC;AACJ;;;;"}

package/js/utils/clone.js.map

@@ -1 +1 @@
-{"version":3,"file":"clone.js","sources":["../../../src/utils/clone.ts"],"sourcesContent":["/**\n * Deeply clones an object or an array.\n *\n * @param something - The object to clone.\n * @returns A deep clone of the provided value.\n *\n * @public\n */\nexport function clone<Something>(something: Something): Something {\n  return JSON.parse(JSON.stringify(something));\n}\n"],"names":[],"mappings":"AAAA;;;;;;;;SAQgB,KAAK,CAAY,SAAoB;IACnD,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,CAAC;AAC/C;;;;"}
+{"version":3,"file":"clone.js","sources":["../../../src/utils/clone.ts"],"sourcesContent":["/**\n * Deeply clones an object or an array.\n *\n * @param something - The object to clone.\n * @returns A deep clone of the provided value.\n *\n * @public\n */\nexport function clone<Something>(something: Something): Something {\n  return JSON.parse(JSON.stringify(something));\n}\n"],"names":[],"mappings":"AAAA;;;;;;;AAOG;AACG,SAAU,KAAK,CAAY,SAAoB,EAAA;IACnD,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,CAAC;AAC/C;;;;"}

package/js/utils/currency-formatter.js

@@ -1,7 +1,7 @@
 /**
  * Regex to detect the format.
  */
-var FORMAT_REGEX = /(i([^id]+))?i+(([^id?]+)(d+)(\?)?)?/;
+const FORMAT_REGEX = /(i([^id]+))?i+(([^id?]+)(d+)(\?)?)?/;
 /**
  * Format a value with a given format.
  *
@@ -30,17 +30,16 @@ var FORMAT_REGEX = /(i([^id]+))?i+(([^id?]+)(d+)(\?)?)?/;
  *
  * @public
  */
-function currencyFormatter(value, format) {
-    if (format === void 0) { format = 'i.iii,dd'; }
-    var _a = numberParts(value), integer = _a.integer, decimal = _a.decimal;
-    var _b = currencyConfig(format), decimalSeparator = _b.decimalSeparator, decimalsNumber = _b.decimalsNumber, integerSeparator = _b.integerSeparator, hideIntegerDecimals = _b.hideIntegerDecimals;
-    var formattedInteger = formatInteger(integer, integerSeparator);
-    var formattedDecimal = formatDecimal(decimal, {
-        decimalsNumber: decimalsNumber,
-        hideIntegerDecimals: hideIntegerDecimals,
-        decimalSeparator: decimalSeparator
+function currencyFormatter(value, format = 'i.iii,dd') {
+    const { integer, decimal } = numberParts(value);
+    const { decimalSeparator, decimalsNumber, integerSeparator, hideIntegerDecimals } = currencyConfig(format);
+    const formattedInteger = formatInteger(integer, integerSeparator);
+    const formattedDecimal = formatDecimal(decimal, {
+        decimalsNumber,
+        hideIntegerDecimals,
+        decimalSeparator
     });
-    return format.replace(FORMAT_REGEX, "" + formattedInteger + formattedDecimal);
+    return format.replace(FORMAT_REGEX, `${formattedInteger}${formattedDecimal}`);
 }
 /**
  * Returns the formatted integer part. This computed returns:
@@ -73,11 +72,10 @@ function formatInteger(integer, integerSeparator) {
  *
  * @internal
  */
-function formatDecimal(decimal, _a) {
-    var decimalsNumber = _a.decimalsNumber, decimalSeparator = _a.decimalSeparator, hideIntegerDecimals = _a.hideIntegerDecimals;
+function formatDecimal(decimal, { decimalsNumber, decimalSeparator, hideIntegerDecimals }) {
     return hideIntegerDecimals && !+decimal
         ? ''
-        : "" + decimalSeparator + decimal.padEnd(decimalsNumber, '0').substring(0, decimalsNumber);
+        : `${decimalSeparator}${decimal.padEnd(decimalsNumber, '0').substring(0, decimalsNumber)}`;
 }
 /**
  * Function that divide fhe format passed as value for get integerSeparator, decimalSeparator
@@ -90,11 +88,10 @@ function formatDecimal(decimal, _a) {
  * @internal
  */
 function currencyConfig(format) {
-    var _a;
-    var _b = (_a = FORMAT_REGEX.exec(format)) !== null && _a !== void 0 ? _a : [], _c = _b[2], integerSeparator = _c === void 0 ? '' : _c, _d = _b[4], decimalSeparator = _d === void 0 ? '' : _d, _e = _b[5], decimals = _e === void 0 ? '' : _e, _f = _b[6], hideIntegerDecimals = _f === void 0 ? '' : _f;
+    const [, , integerSeparator = '', , decimalSeparator = '', decimals = '', hideIntegerDecimals = ''] = FORMAT_REGEX.exec(format) ?? [];
     return {
-        integerSeparator: integerSeparator,
-        decimalSeparator: decimalSeparator,
+        integerSeparator,
+        decimalSeparator,
         decimalsNumber: decimals.length,
         hideIntegerDecimals: !!hideIntegerDecimals
     };
@@ -110,10 +107,10 @@ function currencyConfig(format) {
  * @internal
  */
 function numberParts(value) {
-    var _a = ("" + value).split('.'), integer = _a[0], _b = _a[1], decimal = _b === void 0 ? '' : _b;
+    const [integer, decimal = ''] = `${value}`.split('.');
     return {
-        integer: integer,
-        decimal: decimal
+        integer,
+        decimal
     };
 }
 

package/js/utils/currency-formatter.js.map

@@ -1 +1 @@
-{"version":3,"file":"currency-formatter.js","sources":["../../../src/utils/currency-formatter.ts"],"sourcesContent":["/**\n * Regex to detect the format.\n */\nconst FORMAT_REGEX = /(i([^id]+))?i+(([^id?]+)(d+)(\\?)?)?/;\n\n/**\n * Configuration for format currency.\n */\ninterface CurrencyConfig {\n  /** The character between a group of three integer 'i's and the following one. */\n  integerSeparator: string;\n  /** The character between a group of three integer 'i's and the following one. It also\n   * supports more than one single character. */\n  decimalSeparator: string;\n  /** Length of decimals numbers. It counts the number of 'd's after the integer part. */\n  decimalsNumber: number;\n  /** Boolean value to hide or show the decimal part when it has 0. */\n  hideIntegerDecimals: boolean;\n}\n\n/**\n * Parts of number: integer and decimal.\n */\ninterface NumberParts {\n  /** Integer part of the number as string. */\n  integer: string;\n  /** Decimal part of the number as string. */\n  decimal: string;\n}\n\n/**\n * Format a value with a given format.\n *\n * @param value - Numeric value to be formatted.\n * @param format - Format or mask to be defined as string.\n *\n * @remarks\n * Format:\n * - Use 'i' to define integer numbers.\n * - Use 'd' to define decimal numbers. You can define the length of the decimal part. If the\n * doesn't include decimals, it is filled with zeros until reach the length defined with 'd's.\n * - Integer separator must be defined between the 3rd and the 4th integer 'i' of a group.\n * - Decimal separator must be defined between the last 'i' and the first 'd'. It can be more\n * than one character.\n * - Set whatever you need around the integers and decimals marks.\n * - Default mask: 'i.iii,dd' which returns '1.345,67'.\n * - If you want to hide the decimal part if it's zero (non significant), you can add the `?` symbol\n * after the decimal characters (e.g. 'i.iii,dd?', for `1234` you would get `1.234` instead of\n * `1.234,00`). It defines the value of `hideIntegerDecimals`:\n * - If true (exists) and the value is an integer without decimals, the decimal non significant\n * zeroes are hidden.\n * - If false, the default behaviour will fill with zeros the remaining length until getting\n * the one defined with the 'd's.\n *\n * @returns Formatted number.\n *\n * @public\n */\nexport function currencyFormatter(value: number, format = 'i.iii,dd'): string {\n  const { integer, decimal } = numberParts(value);\n  const { decimalSeparator, decimalsNumber, integerSeparator, hideIntegerDecimals } =\n    currencyConfig(format);\n\n  const formattedInteger = formatInteger(integer, integerSeparator);\n  const formattedDecimal = formatDecimal(decimal, {\n    decimalsNumber,\n    hideIntegerDecimals,\n    decimalSeparator\n  });\n  return format.replace(FORMAT_REGEX, `${formattedInteger}${formattedDecimal}`);\n}\n\n/**\n * Returns the formatted integer part. This computed returns:\n * - integer part with the integer separator added.\n *\n * @param integer - Integer value as a string.\n * @param integerSeparator - Separator to apply in the integer side.\n *\n * The regexp adds the integer separator for each thousand group (each 3 numbers).\n *\n * @returns Formatted integer.\n *\n * @internal\n */\nfunction formatInteger(integer: string, integerSeparator: string): string {\n  return integer.replace(/\\B(?=(\\d{3})+(?!\\d))/g, integerSeparator);\n}\n\n/**\n * Returns the formatted decimal. This computed returns:\n * - decimal part filled with zeros until complete remaining slots defined with the decimal\n * length in the format.\n * - decimal part truncated. The decimal numbers length, defined with the number of 'd's in the\n * format prop. This must MATCH with the number of decimals provided from the adapter.\n *\n * @param decimal - Decimal part as a string.\n * @param CurrencyConfig - From which the `decimalsNumber`, `decimalsSeparator` and\n * `hideIntegerDecimals` are obtained.\n *\n * @returns Formatted integer.\n *\n * @internal\n */\nfunction formatDecimal(\n  decimal: string,\n  {\n    decimalsNumber,\n    decimalSeparator,\n    hideIntegerDecimals\n  }: Omit<CurrencyConfig, 'integerSeparator'>\n): string {\n  return hideIntegerDecimals && !+decimal\n    ? ''\n    : `${decimalSeparator}${decimal.padEnd(decimalsNumber, '0').substring(0, decimalsNumber)}`;\n}\n\n/**\n * Function that divide fhe format passed as value for get integerSeparator, decimalSeparator\n * and decimalsNumber.\n *\n * @param format - Format or mask to apply to the value.\n *\n * @returns Object with properties of the currency config.\n *\n * @internal\n */\nfunction currencyConfig(format: string): CurrencyConfig {\n  const [\n    ,\n    ,\n    integerSeparator = '',\n    ,\n    decimalSeparator = '',\n    decimals = '',\n    hideIntegerDecimals = ''\n  ] = FORMAT_REGEX.exec(format) ?? [];\n  return {\n    integerSeparator,\n    decimalSeparator,\n    decimalsNumber: decimals.length,\n    hideIntegerDecimals: !!hideIntegerDecimals\n  };\n}\n\n/**\n * Divide the number in two parts by separator '.', one of them is the integer number and other\n * the decimals numbers.\n *\n * @param value - Numeric value to be formatted.\n *\n * @returns Parts of number.\n *\n * @internal\n */\nfunction numberParts(value: number): NumberParts {\n  const [integer, decimal = ''] = `${value}`.split('.');\n  return {\n    integer,\n    decimal\n  };\n}\n"],"names":[],"mappings":"AAAA;;;AAGA,IAAM,YAAY,GAAG,qCAAqC,CAAC;AA2B3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;SA4BgB,iBAAiB,CAAC,KAAa,EAAE,MAAmB;IAAnB,uBAAA,EAAA,mBAAmB;IAC5D,IAAA,KAAuB,WAAW,CAAC,KAAK,CAAC,EAAvC,OAAO,aAAA,EAAE,OAAO,aAAuB,CAAC;IAC1C,IAAA,KACJ,cAAc,CAAC,MAAM,CAAC,EADhB,gBAAgB,sBAAA,EAAE,cAAc,oBAAA,EAAE,gBAAgB,sBAAA,EAAE,mBAAmB,yBACvD,CAAC;IAEzB,IAAM,gBAAgB,GAAG,aAAa,CAAC,OAAO,EAAE,gBAAgB,CAAC,CAAC;IAClE,IAAM,gBAAgB,GAAG,aAAa,CAAC,OAAO,EAAE;QAC9C,cAAc,gBAAA;QACd,mBAAmB,qBAAA;QACnB,gBAAgB,kBAAA;KACjB,CAAC,CAAC;IACH,OAAO,MAAM,CAAC,OAAO,CAAC,YAAY,EAAE,KAAG,gBAAgB,GAAG,gBAAkB,CAAC,CAAC;AAChF,CAAC;AAED;;;;;;;;;;;;;AAaA,SAAS,aAAa,CAAC,OAAe,EAAE,gBAAwB;IAC9D,OAAO,OAAO,CAAC,OAAO,CAAC,uBAAuB,EAAE,gBAAgB,CAAC,CAAC;AACpE,CAAC;AAED;;;;;;;;;;;;;;;AAeA,SAAS,aAAa,CACpB,OAAe,EACf,EAI2C;QAHzC,cAAc,oBAAA,EACd,gBAAgB,sBAAA,EAChB,mBAAmB,yBAAA;IAGrB,OAAO,mBAAmB,IAAI,CAAC,CAAC,OAAO;UACnC,EAAE;UACF,KAAG,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,cAAc,CAAG,CAAC;AAC/F,CAAC;AAED;;;;;;;;;;AAUA,SAAS,cAAc,CAAC,MAAc;;IAC9B,IAAA,KAQF,MAAA,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,mCAAI,EAAE,EALjC,UAAqB,EAArB,gBAAgB,mBAAG,EAAE,KAAA,EAErB,UAAqB,EAArB,gBAAgB,mBAAG,EAAE,KAAA,EACrB,UAAa,EAAb,QAAQ,mBAAG,EAAE,KAAA,EACb,UAAwB,EAAxB,mBAAmB,mBAAG,EAAE,KACS,CAAC;IACpC,OAAO;QACL,gBAAgB,kBAAA;QAChB,gBAAgB,kBAAA;QAChB,cAAc,EAAE,QAAQ,CAAC,MAAM;QAC/B,mBAAmB,EAAE,CAAC,CAAC,mBAAmB;KAC3C,CAAC;AACJ,CAAC;AAED;;;;;;;;;;AAUA,SAAS,WAAW,CAAC,KAAa;IAC1B,IAAA,KAA0B,CAAA,KAAG,KAAO,EAAC,KAAK,CAAC,GAAG,CAAC,EAA9C,OAAO,QAAA,EAAE,UAAY,EAAZ,OAAO,mBAAG,EAAE,KAAyB,CAAC;IACtD,OAAO;QACL,OAAO,SAAA;QACP,OAAO,SAAA;KACR,CAAC;AACJ;;;;"}
+{"version":3,"file":"currency-formatter.js","sources":["../../../src/utils/currency-formatter.ts"],"sourcesContent":["/**\n * Regex to detect the format.\n */\nconst FORMAT_REGEX = /(i([^id]+))?i+(([^id?]+)(d+)(\\?)?)?/;\n\n/**\n * Configuration for format currency.\n */\ninterface CurrencyConfig {\n  /** The character between a group of three integer 'i's and the following one. */\n  integerSeparator: string;\n  /** The character between a group of three integer 'i's and the following one. It also\n   * supports more than one single character. */\n  decimalSeparator: string;\n  /** Length of decimals numbers. It counts the number of 'd's after the integer part. */\n  decimalsNumber: number;\n  /** Boolean value to hide or show the decimal part when it has 0. */\n  hideIntegerDecimals: boolean;\n}\n\n/**\n * Parts of number: integer and decimal.\n */\ninterface NumberParts {\n  /** Integer part of the number as string. */\n  integer: string;\n  /** Decimal part of the number as string. */\n  decimal: string;\n}\n\n/**\n * Format a value with a given format.\n *\n * @param value - Numeric value to be formatted.\n * @param format - Format or mask to be defined as string.\n *\n * @remarks\n * Format:\n * - Use 'i' to define integer numbers.\n * - Use 'd' to define decimal numbers. You can define the length of the decimal part. If the\n * doesn't include decimals, it is filled with zeros until reach the length defined with 'd's.\n * - Integer separator must be defined between the 3rd and the 4th integer 'i' of a group.\n * - Decimal separator must be defined between the last 'i' and the first 'd'. It can be more\n * than one character.\n * - Set whatever you need around the integers and decimals marks.\n * - Default mask: 'i.iii,dd' which returns '1.345,67'.\n * - If you want to hide the decimal part if it's zero (non significant), you can add the `?` symbol\n * after the decimal characters (e.g. 'i.iii,dd?', for `1234` you would get `1.234` instead of\n * `1.234,00`). It defines the value of `hideIntegerDecimals`:\n * - If true (exists) and the value is an integer without decimals, the decimal non significant\n * zeroes are hidden.\n * - If false, the default behaviour will fill with zeros the remaining length until getting\n * the one defined with the 'd's.\n *\n * @returns Formatted number.\n *\n * @public\n */\nexport function currencyFormatter(value: number, format = 'i.iii,dd'): string {\n  const { integer, decimal } = numberParts(value);\n  const { decimalSeparator, decimalsNumber, integerSeparator, hideIntegerDecimals } =\n    currencyConfig(format);\n\n  const formattedInteger = formatInteger(integer, integerSeparator);\n  const formattedDecimal = formatDecimal(decimal, {\n    decimalsNumber,\n    hideIntegerDecimals,\n    decimalSeparator\n  });\n  return format.replace(FORMAT_REGEX, `${formattedInteger}${formattedDecimal}`);\n}\n\n/**\n * Returns the formatted integer part. This computed returns:\n * - integer part with the integer separator added.\n *\n * @param integer - Integer value as a string.\n * @param integerSeparator - Separator to apply in the integer side.\n *\n * The regexp adds the integer separator for each thousand group (each 3 numbers).\n *\n * @returns Formatted integer.\n *\n * @internal\n */\nfunction formatInteger(integer: string, integerSeparator: string): string {\n  return integer.replace(/\\B(?=(\\d{3})+(?!\\d))/g, integerSeparator);\n}\n\n/**\n * Returns the formatted decimal. This computed returns:\n * - decimal part filled with zeros until complete remaining slots defined with the decimal\n * length in the format.\n * - decimal part truncated. The decimal numbers length, defined with the number of 'd's in the\n * format prop. This must MATCH with the number of decimals provided from the adapter.\n *\n * @param decimal - Decimal part as a string.\n * @param CurrencyConfig - From which the `decimalsNumber`, `decimalsSeparator` and\n * `hideIntegerDecimals` are obtained.\n *\n * @returns Formatted integer.\n *\n * @internal\n */\nfunction formatDecimal(\n  decimal: string,\n  {\n    decimalsNumber,\n    decimalSeparator,\n    hideIntegerDecimals\n  }: Omit<CurrencyConfig, 'integerSeparator'>\n): string {\n  return hideIntegerDecimals && !+decimal\n    ? ''\n    : `${decimalSeparator}${decimal.padEnd(decimalsNumber, '0').substring(0, decimalsNumber)}`;\n}\n\n/**\n * Function that divide fhe format passed as value for get integerSeparator, decimalSeparator\n * and decimalsNumber.\n *\n * @param format - Format or mask to apply to the value.\n *\n * @returns Object with properties of the currency config.\n *\n * @internal\n */\nfunction currencyConfig(format: string): CurrencyConfig {\n  const [\n    ,\n    ,\n    integerSeparator = '',\n    ,\n    decimalSeparator = '',\n    decimals = '',\n    hideIntegerDecimals = ''\n  ] = FORMAT_REGEX.exec(format) ?? [];\n  return {\n    integerSeparator,\n    decimalSeparator,\n    decimalsNumber: decimals.length,\n    hideIntegerDecimals: !!hideIntegerDecimals\n  };\n}\n\n/**\n * Divide the number in two parts by separator '.', one of them is the integer number and other\n * the decimals numbers.\n *\n * @param value - Numeric value to be formatted.\n *\n * @returns Parts of number.\n *\n * @internal\n */\nfunction numberParts(value: number): NumberParts {\n  const [integer, decimal = ''] = `${value}`.split('.');\n  return {\n    integer,\n    decimal\n  };\n}\n"],"names":[],"mappings":"AAAA;;AAEG;AACH,MAAM,YAAY,GAAG,qCAAqC,CAAC;AA2B3D;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;SACa,iBAAiB,CAAC,KAAa,EAAE,MAAM,GAAG,UAAU,EAAA;IAClE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC;AAChD,IAAA,MAAM,EAAE,gBAAgB,EAAE,cAAc,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,GAC/E,cAAc,CAAC,MAAM,CAAC,CAAC;IAEzB,MAAM,gBAAgB,GAAG,aAAa,CAAC,OAAO,EAAE,gBAAgB,CAAC,CAAC;AAClE,IAAA,MAAM,gBAAgB,GAAG,aAAa,CAAC,OAAO,EAAE;QAC9C,cAAc;QACd,mBAAmB;QACnB,gBAAgB;AACjB,KAAA,CAAC,CAAC;AACH,IAAA,OAAO,MAAM,CAAC,OAAO,CAAC,YAAY,EAAE,CAAG,EAAA,gBAAgB,CAAG,EAAA,gBAAgB,CAAE,CAAA,CAAC,CAAC;AAChF,CAAC;AAED;;;;;;;;;;;;AAYG;AACH,SAAS,aAAa,CAAC,OAAe,EAAE,gBAAwB,EAAA;IAC9D,OAAO,OAAO,CAAC,OAAO,CAAC,uBAAuB,EAAE,gBAAgB,CAAC,CAAC;AACpE,CAAC;AAED;;;;;;;;;;;;;;AAcG;AACH,SAAS,aAAa,CACpB,OAAe,EACf,EACE,cAAc,EACd,gBAAgB,EAChB,mBAAmB,EACsB,EAAA;AAE3C,IAAA,OAAO,mBAAmB,IAAI,CAAC,CAAC,OAAO;AACrC,UAAE,EAAE;UACF,GAAG,gBAAgB,CAAA,EAAG,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,cAAc,CAAC,EAAE,CAAC;AAC/F,CAAC;AAED;;;;;;;;;AASG;AACH,SAAS,cAAc,CAAC,MAAc,EAAA;AACpC,IAAA,MAAM,KAGJ,gBAAgB,GAAG,EAAE,IAErB,gBAAgB,GAAG,EAAE,EACrB,QAAQ,GAAG,EAAE,EACb,mBAAmB,GAAG,EAAE,CACzB,GAAG,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;IACpC,OAAO;QACL,gBAAgB;QAChB,gBAAgB;QAChB,cAAc,EAAE,QAAQ,CAAC,MAAM;QAC/B,mBAAmB,EAAE,CAAC,CAAC,mBAAmB;KAC3C,CAAC;AACJ,CAAC;AAED;;;;;;;;;AASG;AACH,SAAS,WAAW,CAAC,KAAa,EAAA;AAChC,IAAA,MAAM,CAAC,OAAO,EAAE,OAAO,GAAG,EAAE,CAAC,GAAG,CAAG,EAAA,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACtD,OAAO;QACL,OAAO;QACP,OAAO;KACR,CAAC;AACJ;;;;"}

package/js/utils/debounce.js

@@ -34,30 +34,25 @@
  *
  * @public
  */
-var debounce = function (fn, debounceTimeInMs, _a) {
-    var _b = _a === void 0 ? {} : _a, _c = _b.leading, leading = _c === void 0 ? false : _c, _d = _b.trailing, trailing = _d === void 0 ? true : _d;
-    var timer;
-    var debouncedFn = function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        var isFirstLeadingCall = leading && !timer;
+const debounce = (fn, debounceTimeInMs, { leading = false, trailing = true } = {}) => {
+    let timer;
+    const debouncedFn = (...args) => {
+        const isFirstLeadingCall = leading && !timer;
         if (isFirstLeadingCall) {
-            fn.apply(void 0, args);
+            fn(...args);
         }
-        var trailingFn = function () {
+        const trailingFn = () => {
             timer = undefined;
             if (!isFirstLeadingCall && trailing) {
-                fn.apply(void 0, args);
+                fn(...args);
             }
         };
         if (timer) {
             clearTimeout(timer);
         }
-        timer = setTimeout(function () { return trailingFn(); }, debounceTimeInMs);
+        timer = setTimeout(() => trailingFn(), debounceTimeInMs);
     };
-    debouncedFn.cancel = function () {
+    debouncedFn.cancel = () => {
         if (timer) {
             clearTimeout(timer);
         }

package/js/utils/debounce.js.map

@@ -1 +1 @@
-{"version":3,"file":"debounce.js","sources":["../../../src/utils/debounce.ts"],"sourcesContent":["/* eslint-disable max-len */\nimport { DebouncedFunction, DebounceOptions } from './types';\n\n/**\n * Util function that returns a debounced version of the function passed as parameter. It can use\n * the leading strategy, trailing strategy or both. Using both would result in one leading\n * execution guaranteed and trailing executions only if there are further calls during the length\n * of the debounce time.\n *\n * @param fn - Function to be debounced.\n * @param debounceTimeInMs - The time of debounce in ms.\n * @param debounceOptions - The options for the debounce strategy.\n * @returns A new function with the debounce.\n *\n * @example Debounce options:\n *\n * Given this code, where you configure the `trailing` and `leading` options:\n *\n * ```js\n * const log = debounce(name => console.log(name), 1000, {\n *   leading\n *   trailing\n * });\n *\n *  log('a'); // +0ms\n *  log('b'); // +0ms\n *  log('c'); // +0ms\n *  setTimeout(() => log('d'), 1000); // +1000ms\n *  setTimeout(() => log('e'), 1500); // +500ms\n *  setTimeout(() => log('f'), 2600); // +1100ms\n * ```\n *\n * | &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;\\\\ trailing<br/> leading \\\\ | **`false`** | **`true`**    |\n * |:----------------------------------------------------------------------------------------------------------|-------------|---------------|\n * | **`false`**                                                                                               |             | c, e, f       |\n * | **`true`**                                                                                                | a, d, f     | a, c, d, e, f |\n *\n * @public\n */\nexport const debounce = <Params extends any[]>(\n  fn: (...args: Params) => void,\n  debounceTimeInMs: number,\n  { leading = false, trailing = true }: DebounceOptions = {}\n): DebouncedFunction<Params> => {\n  let timer: ReturnType<typeof setTimeout> | undefined;\n  const debouncedFn: DebouncedFunction<Params> = (...args) => {\n    const isFirstLeadingCall = leading && !timer;\n    if (isFirstLeadingCall) {\n      fn(...args);\n    }\n    const trailingFn = (): void => {\n      timer = undefined;\n      if (!isFirstLeadingCall && trailing) {\n        fn(...args);\n      }\n    };\n    if (timer) {\n      clearTimeout(timer);\n    }\n    timer = setTimeout(() => trailingFn(), debounceTimeInMs);\n  };\n\n  debouncedFn.cancel = () => {\n    if (timer) {\n      clearTimeout(timer);\n    }\n  };\n  return debouncedFn;\n};\n"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAoCa,QAAQ,GAAG,UACtB,EAA6B,EAC7B,gBAAwB,EACxB,EAA0D;QAA1D,qBAAwD,EAAE,KAAA,EAAxD,eAAe,EAAf,OAAO,mBAAG,KAAK,KAAA,EAAE,gBAAe,EAAf,QAAQ,mBAAG,IAAI,KAAA;IAElC,IAAI,KAAgD,CAAC;IACrD,IAAM,WAAW,GAA8B;QAAC,cAAO;aAAP,UAAO,EAAP,qBAAO,EAAP,IAAO;YAAP,yBAAO;;QACrD,IAAM,kBAAkB,GAAG,OAAO,IAAI,CAAC,KAAK,CAAC;QAC7C,IAAI,kBAAkB,EAAE;YACtB,EAAE,eAAI,IAAI,EAAE;SACb;QACD,IAAM,UAAU,GAAG;YACjB,KAAK,GAAG,SAAS,CAAC;YAClB,IAAI,CAAC,kBAAkB,IAAI,QAAQ,EAAE;gBACnC,EAAE,eAAI,IAAI,EAAE;aACb;SACF,CAAC;QACF,IAAI,KAAK,EAAE;YACT,YAAY,CAAC,KAAK,CAAC,CAAC;SACrB;QACD,KAAK,GAAG,UAAU,CAAC,cAAM,OAAA,UAAU,EAAE,GAAA,EAAE,gBAAgB,CAAC,CAAC;KAC1D,CAAC;IAEF,WAAW,CAAC,MAAM,GAAG;QACnB,IAAI,KAAK,EAAE;YACT,YAAY,CAAC,KAAK,CAAC,CAAC;SACrB;KACF,CAAC;IACF,OAAO,WAAW,CAAC;AACrB;;;;"}
+{"version":3,"file":"debounce.js","sources":["../../../src/utils/debounce.ts"],"sourcesContent":["/* eslint-disable max-len */\nimport { DebouncedFunction, DebounceOptions } from './types';\n\n/**\n * Util function that returns a debounced version of the function passed as parameter. It can use\n * the leading strategy, trailing strategy or both. Using both would result in one leading\n * execution guaranteed and trailing executions only if there are further calls during the length\n * of the debounce time.\n *\n * @param fn - Function to be debounced.\n * @param debounceTimeInMs - The time of debounce in ms.\n * @param debounceOptions - The options for the debounce strategy.\n * @returns A new function with the debounce.\n *\n * @example Debounce options:\n *\n * Given this code, where you configure the `trailing` and `leading` options:\n *\n * ```js\n * const log = debounce(name => console.log(name), 1000, {\n *   leading\n *   trailing\n * });\n *\n *  log('a'); // +0ms\n *  log('b'); // +0ms\n *  log('c'); // +0ms\n *  setTimeout(() => log('d'), 1000); // +1000ms\n *  setTimeout(() => log('e'), 1500); // +500ms\n *  setTimeout(() => log('f'), 2600); // +1100ms\n * ```\n *\n * | &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;\\\\ trailing<br/> leading \\\\ | **`false`** | **`true`**    |\n * |:----------------------------------------------------------------------------------------------------------|-------------|---------------|\n * | **`false`**                                                                                               |             | c, e, f       |\n * | **`true`**                                                                                                | a, d, f     | a, c, d, e, f |\n *\n * @public\n */\nexport const debounce = <Params extends any[]>(\n  fn: (...args: Params) => void,\n  debounceTimeInMs: number,\n  { leading = false, trailing = true }: DebounceOptions = {}\n): DebouncedFunction<Params> => {\n  let timer: ReturnType<typeof setTimeout> | undefined;\n  const debouncedFn: DebouncedFunction<Params> = (...args) => {\n    const isFirstLeadingCall = leading && !timer;\n    if (isFirstLeadingCall) {\n      fn(...args);\n    }\n    const trailingFn = (): void => {\n      timer = undefined;\n      if (!isFirstLeadingCall && trailing) {\n        fn(...args);\n      }\n    };\n    if (timer) {\n      clearTimeout(timer);\n    }\n    timer = setTimeout(() => trailingFn(), debounceTimeInMs);\n  };\n\n  debouncedFn.cancel = () => {\n    if (timer) {\n      clearTimeout(timer);\n    }\n  };\n  return debouncedFn;\n};\n"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCG;MACU,QAAQ,GAAG,CACtB,EAA6B,EAC7B,gBAAwB,EACxB,EAAE,OAAO,GAAG,KAAK,EAAE,QAAQ,GAAG,IAAI,EAAsB,GAAA,EAAE,KAC7B;AAC7B,IAAA,IAAI,KAAgD,CAAC;AACrD,IAAA,MAAM,WAAW,GAA8B,CAAC,GAAG,IAAI,KAAI;AACzD,QAAA,MAAM,kBAAkB,GAAG,OAAO,IAAI,CAAC,KAAK,CAAC;AAC7C,QAAA,IAAI,kBAAkB,EAAE;AACtB,YAAA,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC;AACb,SAAA;QACD,MAAM,UAAU,GAAG,MAAW;YAC5B,KAAK,GAAG,SAAS,CAAC;AAClB,YAAA,IAAI,CAAC,kBAAkB,IAAI,QAAQ,EAAE;AACnC,gBAAA,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC;AACb,aAAA;AACH,SAAC,CAAC;AACF,QAAA,IAAI,KAAK,EAAE;YACT,YAAY,CAAC,KAAK,CAAC,CAAC;AACrB,SAAA;QACD,KAAK,GAAG,UAAU,CAAC,MAAM,UAAU,EAAE,EAAE,gBAAgB,CAAC,CAAC;AAC3D,KAAC,CAAC;AAEF,IAAA,WAAW,CAAC,MAAM,GAAG,MAAK;AACxB,QAAA,IAAI,KAAK,EAAE;YACT,YAAY,CAAC,KAAK,CAAC,CAAC;AACrB,SAAA;AACH,KAAC,CAAC;AACF,IAAA,OAAO,WAAW,CAAC;AACrB;;;;"}

package/js/utils/filters.js

@@ -3,14 +3,34 @@
  *
  * @param someFilters - A list of filters to compare.
  * @param anotherFilters - Another list of filters to compare.
+ *
  * @returns True if the two lists of filters are equal, which means that they have the same
  * filters. The position of the filter does not matter for this check.
+ *
  * @public
  */
 function areFiltersDifferent(someFilters, anotherFilters) {
     return (someFilters.length !== anotherFilters.length ||
-        someFilters.some(function (filter) { return !anotherFilters.find(function (otherFilter) { return otherFilter.id === filter.id; }); }));
+        someFilters.some(filter => !anotherFilters.find(otherFilter => otherFilter.id === filter.id)));
+}
+/**
+ * Helper method which creates the filter entity from the filter ir of the url.
+ *
+ * @param filterIds - List of filter ids from the url.
+ *
+ * @returns A list of  filters.
+ *
+ * @public
+ */
+function createRawFilters(filterIds) {
+    return filterIds.map(filterId => {
+        return {
+            id: filterId,
+            modelName: 'RawFilter',
+            selected: true
+        };
+    });
 }
 
-export { areFiltersDifferent };
+export { areFiltersDifferent, createRawFilters };
 //# sourceMappingURL=filters.js.map

package/js/utils/filters.js.map

@@ -1 +1 @@
-{"version":3,"file":"filters.js","sources":["../../../src/utils/filters.ts"],"sourcesContent":["import { Filter } from '@empathyco/x-types';\n\n/**\n * Compares if two lists contains the same filters.\n *\n * @param someFilters - A list of filters to compare.\n * @param anotherFilters - Another list of filters to compare.\n * @returns True if the two lists of filters are equal, which means that they have the same\n * filters. The position of the filter does not matter for this check.\n * @public\n */\nexport function areFiltersDifferent(someFilters: Filter[], anotherFilters: Filter[]): boolean {\n  return (\n    someFilters.length !== anotherFilters.length ||\n    someFilters.some(filter => !anotherFilters.find(otherFilter => otherFilter.id === filter.id))\n  );\n}\n"],"names":[],"mappings":"AAEA;;;;;;;;;SASgB,mBAAmB,CAAC,WAAqB,EAAE,cAAwB;IACjF,QACE,WAAW,CAAC,MAAM,KAAK,cAAc,CAAC,MAAM;QAC5C,WAAW,CAAC,IAAI,CAAC,UAAA,MAAM,IAAI,OAAA,CAAC,cAAc,CAAC,IAAI,CAAC,UAAA,WAAW,IAAI,OAAA,WAAW,CAAC,EAAE,KAAK,MAAM,CAAC,EAAE,GAAA,CAAC,GAAA,CAAC,EAC7F;AACJ;;;;"}
+{"version":3,"file":"filters.js","sources":["../../../src/utils/filters.ts"],"sourcesContent":["import { Filter, RawFilter } from '@empathyco/x-types';\n\n/**\n * Compares if two lists contains the same filters.\n *\n * @param someFilters - A list of filters to compare.\n * @param anotherFilters - Another list of filters to compare.\n *\n * @returns True if the two lists of filters are equal, which means that they have the same\n * filters. The position of the filter does not matter for this check.\n *\n * @public\n */\nexport function areFiltersDifferent(someFilters: Filter[], anotherFilters: Filter[]): boolean {\n  return (\n    someFilters.length !== anotherFilters.length ||\n    someFilters.some(filter => !anotherFilters.find(otherFilter => otherFilter.id === filter.id))\n  );\n}\n\n/**\n * Helper method which creates the filter entity from the filter ir of the url.\n *\n * @param filterIds - List of filter ids from the url.\n *\n * @returns A list of  filters.\n *\n * @public\n */\nexport function createRawFilters(filterIds: Array<Filter['id']>): RawFilter[] {\n  return filterIds.map(filterId => {\n    return {\n      id: filterId as string,\n      modelName: 'RawFilter',\n      selected: true\n    };\n  });\n}\n"],"names":[],"mappings":"AAEA;;;;;;;;;;AAUG;AACa,SAAA,mBAAmB,CAAC,WAAqB,EAAE,cAAwB,EAAA;AACjF,IAAA,QACE,WAAW,CAAC,MAAM,KAAK,cAAc,CAAC,MAAM;QAC5C,WAAW,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,WAAW,IAAI,WAAW,CAAC,EAAE,KAAK,MAAM,CAAC,EAAE,CAAC,CAAC,EAC7F;AACJ,CAAC;AAED;;;;;;;;AAQG;AACG,SAAU,gBAAgB,CAAC,SAA8B,EAAA;AAC7D,IAAA,OAAO,SAAS,CAAC,GAAG,CAAC,QAAQ,IAAG;QAC9B,OAAO;AACL,YAAA,EAAE,EAAE,QAAkB;AACtB,YAAA,SAAS,EAAE,WAAW;AACtB,YAAA,QAAQ,EAAE,IAAI;SACf,CAAC;AACJ,KAAC,CAAC,CAAC;AACL;;;;"}

package/js/utils/focus.js

@@ -0,0 +1,11 @@
+/**
+ * Comma separated list of common focusable selectors.
+ *
+ * @public
+ */
+/* eslint-disable max-len */
+const FOCUSABLE_SELECTORS = 'a[href], button:not([disabled]), details, input:not([disabled]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex="-1"])';
+/* eslint-enable max-len */
+
+export { FOCUSABLE_SELECTORS };
+//# sourceMappingURL=focus.js.map

package/js/utils/focus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"focus.js","sources":["../../../src/utils/focus.ts"],"sourcesContent":["/**\n * Comma separated list of common focusable selectors.\n *\n * @public\n */\n/* eslint-disable max-len */\nexport const FOCUSABLE_SELECTORS =\n  'a[href], button:not([disabled]), details, input:not([disabled]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex=\"-1\"])';\n/* eslint-enable max-len */\n"],"names":[],"mappings":"AAAA;;;;AAIG;AACH;AACO,MAAM,mBAAmB,GAC9B,qJAAqJ;AACvJ;;;;"}

package/js/utils/function.js.map

@@ -1 +1 @@
-{"version":3,"file":"function.js","sources":["../../../src/utils/function.ts"],"sourcesContent":["/**\n * Util function to be used as default parameter for callbacks, or optional functions\n * implementations.\n *\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/no-empty-function\nexport function noOp(): any {}\n"],"names":[],"mappings":"AAAA;;;;;;AAMA;SACgB,IAAI;;;;"}
+{"version":3,"file":"function.js","sources":["../../../src/utils/function.ts"],"sourcesContent":["/**\n * Util function to be used as default parameter for callbacks, or optional functions\n * implementations.\n *\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/no-empty-function\nexport function noOp(): any {}\n"],"names":[],"mappings":"AAAA;;;;;AAKG;AACH;AACM,SAAU,IAAI,GAAA;;;;"}

package/js/utils/get-url-parameters.js

@@ -5,9 +5,9 @@
  * @returns The parameter value from the url.
  * @public
  */
-var getURLParameter = function (param) {
-    var regex = new RegExp("[?|&]" + param + "=([^&;]+?)(&|#|;|$)");
-    var paramValue = regex.exec(window.location.href);
+const getURLParameter = (param) => {
+    const regex = new RegExp(`[?|&]${param}=([^&;]+?)(&|#|;|$)`);
+    const paramValue = regex.exec(window.location.href);
     return paramValue ? decodeURIComponent(paramValue[1].replace(/\+/g, '%20')) : null;
 };
 

package/js/utils/get-url-parameters.js.map

@@ -1 +1 @@
-{"version":3,"file":"get-url-parameters.js","sources":["../../../src/utils/get-url-parameters.ts"],"sourcesContent":["/**\n * Get one parameter value from the url.\n *\n * @param param - The parameter to get from the url.\n * @returns The parameter value from the url.\n * @public\n */\nexport const getURLParameter = (param: string): string | null => {\n  const regex = new RegExp(`[?|&]${param}=([^&;]+?)(&|#|;|$)`);\n  const paramValue = regex.exec(window.location.href);\n  return paramValue ? decodeURIComponent(paramValue[1].replace(/\\+/g, '%20')) : null;\n};\n"],"names":[],"mappings":"AAAA;;;;;;;IAOa,eAAe,GAAG,UAAC,KAAa;IAC3C,IAAM,KAAK,GAAG,IAAI,MAAM,CAAC,UAAQ,KAAK,wBAAqB,CAAC,CAAC;IAC7D,IAAM,UAAU,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IACpD,OAAO,UAAU,GAAG,kBAAkB,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC;AACrF;;;;"}
+{"version":3,"file":"get-url-parameters.js","sources":["../../../src/utils/get-url-parameters.ts"],"sourcesContent":["/**\n * Get one parameter value from the url.\n *\n * @param param - The parameter to get from the url.\n * @returns The parameter value from the url.\n * @public\n */\nexport const getURLParameter = (param: string): string | null => {\n  const regex = new RegExp(`[?|&]${param}=([^&;]+?)(&|#|;|$)`);\n  const paramValue = regex.exec(window.location.href);\n  return paramValue ? decodeURIComponent(paramValue[1].replace(/\\+/g, '%20')) : null;\n};\n"],"names":[],"mappings":"AAAA;;;;;;AAMG;AACU,MAAA,eAAe,GAAG,CAAC,KAAa,KAAmB;IAC9D,MAAM,KAAK,GAAG,IAAI,MAAM,CAAC,CAAQ,KAAA,EAAA,KAAK,CAAqB,mBAAA,CAAA,CAAC,CAAC;AAC7D,IAAA,MAAM,UAAU,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IACpD,OAAO,UAAU,GAAG,kBAAkB,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC;AACrF;;;;"}

package/js/utils/html.js

@@ -9,7 +9,24 @@
  */
 function isElementEqualOrContained(a, b) {
     return a === b || a.contains(b);
+}
+/**
+ * Returns the target element for a given event. The target element is obtained from `composedPath`
+ * Event method because if the event is triggered inside a Shadow DOM context, `event.target` points
+ * to Shadow DOM element, not the element that triggered the event. `composedPath` method also is
+ * available in a non-shadow DOM context.
+ *
+ * @remarks In a shadow DOM context, this function only works if the Shadow DOM uses `open`
+ * encapsulation mode.
+ *
+ * @param event - Event which takes place in the DOM.
+ * @returns Target Element of the event.
+ *
+ * @public
+ */
+function getTargetElement(event) {
+    return event.composedPath()[0];
 }
 
-export { isElementEqualOrContained };
+export { getTargetElement, isElementEqualOrContained };
 //# sourceMappingURL=html.js.map

package/js/utils/html.js.map

@@ -1 +1 @@
-{"version":3,"file":"html.js","sources":["../../../src/utils/html.ts"],"sourcesContent":["/**\n * Returns true if the two elements are the same, or if `b` is a child of `a`.\n *\n * @param a - The element to check if it is equal to `b` or if it contains `b`.\n * @param b - The element to check if it is equal to `a` or contained inside it.\n * @returns True if `a` is equal to `b` or if it contains `b`.\n *\n * @public\n */\nexport function isElementEqualOrContained(a: Element, b: Element): boolean {\n  return a === b || a.contains(b);\n}\n"],"names":[],"mappings":"AAAA;;;;;;;;;SASgB,yBAAyB,CAAC,CAAU,EAAE,CAAU;IAC9D,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;AAClC;;;;"}
+{"version":3,"file":"html.js","sources":["../../../src/utils/html.ts"],"sourcesContent":["/**\n * Returns true if the two elements are the same, or if `b` is a child of `a`.\n *\n * @param a - The element to check if it is equal to `b` or if it contains `b`.\n * @param b - The element to check if it is equal to `a` or contained inside it.\n * @returns True if `a` is equal to `b` or if it contains `b`.\n *\n * @public\n */\nexport function isElementEqualOrContained(a: Element, b: Element): boolean {\n  return a === b || a.contains(b);\n}\n\n/**\n * Returns the target element for a given event. The target element is obtained from `composedPath`\n * Event method because if the event is triggered inside a Shadow DOM context, `event.target` points\n * to Shadow DOM element, not the element that triggered the event. `composedPath` method also is\n * available in a non-shadow DOM context.\n *\n * @remarks In a shadow DOM context, this function only works if the Shadow DOM uses `open`\n * encapsulation mode.\n *\n * @param event - Event which takes place in the DOM.\n * @returns Target Element of the event.\n *\n * @public\n */\nexport function getTargetElement(event: Event): Element {\n  return event.composedPath()[0] as Element;\n}\n"],"names":[],"mappings":"AAAA;;;;;;;;AAQG;AACa,SAAA,yBAAyB,CAAC,CAAU,EAAE,CAAU,EAAA;IAC9D,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;AAClC,CAAC;AAED;;;;;;;;;;;;;AAaG;AACG,SAAU,gBAAgB,CAAC,KAAY,EAAA;AAC3C,IAAA,OAAO,KAAK,CAAC,YAAY,EAAE,CAAC,CAAC,CAAY,CAAC;AAC5C;;;;"}

package/js/utils/is-new-query.js

@@ -0,0 +1,48 @@
+import { isStringEmpty } from './string.js';
+
+/**
+ * Regex for splitting a query into its words.
+ *
+ * @public
+ */
+const SPLIT_WORDS_REGEX = /[\s-]/;
+/**
+ * Compares two queries to know if the new one is a refined query from the previous one or a new
+ * one.
+ *
+ * A refined query is a query which has the previous query or part of it.
+ * Example:
+ * - previousQuery = 'lego star'.
+ * - newQuery = 'lego star wars'.
+ *
+ * Example:
+ * - previousQuery = 'lego star wars'.
+ * - newQuery = 'lego star'.
+ *
+ * A new query is a query which has not the previous query.
+ * Example:
+ * - previousQuery = 'lego star'.
+ * - newQuery = 'lego wars'.
+ *
+ * In this case, it is changing the word set, because a word is changed by another one, so
+ * this is changing the search intention.
+ *
+ * @param newQuery - The new query.
+ * @param previousQuery - The previous query.
+ *
+ * @returns A boolean which flags if the query is refined or not.
+ *
+ * @public
+ */
+function isNewQuery(newQuery, previousQuery) {
+    const isNewQueryEmpty = isStringEmpty(newQuery);
+    const isPreviousQueryEmpty = isStringEmpty(previousQuery);
+    const previousQueryWords = previousQuery.split(SPLIT_WORDS_REGEX);
+    const newQueryWords = newQuery.split(SPLIT_WORDS_REGEX);
+    return (!previousQueryWords.every(previousQueryWord => newQueryWords.some(newQueryWord => newQueryWord.includes(previousQueryWord) || previousQueryWord.includes(newQueryWord))) ||
+        (isNewQueryEmpty && !isPreviousQueryEmpty) ||
+        (!isNewQueryEmpty && isPreviousQueryEmpty));
+}
+
+export { SPLIT_WORDS_REGEX, isNewQuery };
+//# sourceMappingURL=is-new-query.js.map