@sankhyalabs/core 2.7.1 → 2.9.0

package/src/dataunit/DataUnit.ts

@@ -1,5 +1,5 @@
 import { convertType, toString } from "./metadata/DataType.js";
-import { FieldDescriptor, Filter, FilterProvider, Sort, SortingProvider, UnitMetadata } from "./metadata/UnitMetadata.js";
+import { ChildDescriptor, FieldDescriptor, Filter, FilterProvider, Sort, SortingProvider, UnitMetadata } from "./metadata/UnitMetadata.js";
 
 import { Action, DataUnitAction, ExecutionContext } from "./state/action/DataUnitAction.js";
 import StateManager from "./state/StateManager.js";
@@ -459,6 +459,24 @@ export default class DataUnit {
         return getMetadata(this._stateManager);
     }
 
+     /**
+     * 
+     * Obtém informações da ligação para um DataUnit filho.
+     * 
+     * @param name - Nome do DataUnit que se deseja.
+     * 
+     * @returns - As informações sobre a ligação solicitada. Pode retornar undefined.
+     * 
+     */
+    public getChildInfo(name: string): ChildDescriptor|undefined {
+        const children = this.metadata?.children;
+        if(children == undefined){
+            return;
+        }
+
+        return children.find(child => child.name === name);
+    }
+
     /**
      * 
      * Define a propriedade records da instância da classe com um novo valor e chama o método dispatchAction para notificar os observers da aplicação sobre a mudança.

package/src/dataunit/metadata/UnitMetadata.ts

@@ -4,6 +4,17 @@ export interface UnitMetadata{
     name: string;
     label: string;
     fields: Array<FieldDescriptor>;
+    children?: Array<ChildDescriptor>
+}
+
+export interface ChildDescriptor{
+    name: string;
+    links: Array<ChildLink>;
+}
+
+export interface ChildLink{
+    source: string;
+    target: string;
 }
 
 export interface FieldDescriptor {

package/src/utils/ArrayUtils.ts

@@ -1,4 +1,13 @@
 import { StringUtils } from "./StringUtils.js";
+
+type FilterRecursivelyParams<T> = {
+    query: string;
+    list: T[];
+    fieldName: string;
+    key: string;
+    sortAlphabetically?: boolean;
+}
+
 /**
  * `ArrayUtils`: Utilitário com a responsabilidade de manipular Arrays.
  */
@@ -33,6 +42,34 @@ export default class ArrayUtils {
     private static normalizeSearchString(original:string ): string{
         return StringUtils.replaceAccentuatedCharsKeepSymbols(original.toUpperCase());
     }
+    
+    /**
+     * Filtra um array a partir de um critério textual.
+     * 
+     * @param {string} options.query - Texto a ser usado no filtro.
+     * @param {Object[]} options.list - Lista a ser filtrada.
+     * @param {string} options.fieldName - Nome do campo onde irá ser feito a busca a partir do parâmetro `query`.
+     * @param {string} options.key - Nome do atributo onde conterá outros atributos filhos.
+     * @param {boolean} [options.sortAlphabetically=true] - Determina se o resultado deve ser ordenado ou mantido na ordem original. Por padrão ordena.
+     * @returns - Uma lista recursivamente filtrada e ordenado conforme necessidade..
+     */
+    static applyStringFilterRecursively<ListType>({ query, list, fieldName, key, sortAlphabetically = true }: FilterRecursivelyParams<ListType>): ListType[] {   
+        const normalizedArgument = ArrayUtils.normalizeSearchString(query);    
+        const alphabeticalSortingList = sortAlphabetically ? ArrayUtils.sortAlphabetically(list, fieldName) : list;
+        
+        const recursiveReducer = (initialList: ListType[], item: any) => {  
+            const itemValue = ArrayUtils.normalizeSearchString(item[fieldName]);
+            if (itemValue.includes(normalizedArgument)) {
+                initialList.push(item);
+                return initialList;
+            }
+            item[key] = Array.isArray(item[key]) ?  item[key].reduce(recursiveReducer, []) : [];
+            if (item[key].length) initialList.push({ ...item, [key]: item[key] });
+            return initialList;
+        }
+        
+        return alphabeticalSortingList.reduce(recursiveReducer, []); 
+    }
 
     /**
      * Ordena valores de um array alfabeticamente.