minor tweaks and enhancements

Author: vegegoku

domino-ui/src/main/java/org/dominokit/domino/ui/cards/CardHeader.java

@@ -63,7 +63,7 @@ public static CardHeader create() {
     subHeader = LazyChild.of(div().addCss(dui_card_sub_header), element);
     title = LazyChild.of(div().addCss(dui_card_title), mainHeader);
     mainTitle = LazyChild.of(h(2).addCss(dui_card_main_title), title);
-    description = LazyChild.of(small().addCss(dui_card_description), mainTitle);
+    description = LazyChild.of(small().addCss(dui_card_description), title);
 
     init(this);
   }

domino-ui/src/main/java/org/dominokit/domino/ui/datatable/plugins/grouping/GroupCell.java

@@ -26,6 +26,8 @@ public class GroupCell<T>
     extends TableCell<
         T, HTMLTableCellElement, GroupCellInfo<T>, GroupCellRenderer<T>, GroupCell<T>> {
 
+  private GroupingPlugin.DataGroup<T> dataGroup;
+
   /**
    * Constructs a new {@code RowCell} with the given cell information and column configuration.
    *
@@ -35,6 +37,14 @@ public GroupCell(GroupCellInfo<T> cellInfo) {
     super(cellInfo);
   }
 
+  public GroupingPlugin.DataGroup<T> getDataGroup() {
+    return dataGroup;
+  }
+
+  void setDataGroup(GroupingPlugin.DataGroup<T> dataGroup) {
+    this.dataGroup = dataGroup;
+  }
+
   @Override
   protected GroupCellRenderer<T> getDefaultCellRenderer() {
     return cellInfo -> elements.text();

domino-ui/src/main/java/org/dominokit/domino/ui/datatable/plugins/grouping/GroupingPlugin.java

@@ -136,6 +136,8 @@ public void appendRow(DataTable<T> dataTable, TableRow<T> tableRow) {
       GroupCell<T> groupCell = new GroupCell<>(cellInfo);
       DataGroup<T> dataGroup = new DataGroup<>(tableRow, groupCell);
 
+      groupCell.setDataGroup(dataGroup);
+
       ToggleIcon<?, ?> groupToggleIcon =
           groupExpandedCollapseIconSupplier
               .get()
@@ -344,6 +346,10 @@ private boolean isOdd(TableRow<T> tableRow) {
     public void render() {
       groupRenderer.render(groupCell);
     }
+
+    public List<TableRow<T>> getGroupRows() {
+      return new ArrayList<>(groupRows);
+    }
   }
 
   /**

domino-ui/src/main/java/org/dominokit/domino/ui/datatable/store/LocalListDataStore.java

@@ -690,6 +690,33 @@ public void updateRecords(int startIndex, Collection<T> records) {
     load();
   }
 
+  /**
+   * Inserts a new record if it does not exist, or updates the existing record if it is already
+   * present.
+   *
+   * @param record The record to be inserted or updated.
+   */
+  public void upsertRecord(T record) {
+    if (original.contains(record)) {
+      updateRecord(record);
+    } else {
+      addRecord(record);
+    }
+  }
+
+  /**
+   * Inserts or updates a collection of records in the data store. Each record in the collection is
+   * processed individually, and the upsert operation is performed for each record.
+   *
+   * @param records the collection of records to be inserted or updated, where each record
+   *     represents an entity to be persisted in the data store
+   */
+  public void upsertRecords(Collection<T> records) {
+    for (T record : records) {
+      upsertRecord(record);
+    }
+  }
+
   /**
    * Internal method to update a single record at a specified index, updating both the original and
    * filtered lists.

domino-ui/src/main/java/org/dominokit/domino/ui/forms/UploadBox.java

@@ -18,8 +18,10 @@
 import static java.util.Objects.nonNull;
 import static org.dominokit.domino.ui.utils.Domino.*;
 
+import elemental2.core.Uint8Array;
 import elemental2.dom.File;
 import elemental2.dom.HTMLInputElement;
+import elemental2.promise.Promise;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.stream.Collectors;
@@ -309,4 +311,18 @@ public UploadBox setMultiple(boolean multiple) {
   public boolean getMultiple() {
     return this.getInputElement().element().multiple;
   }
+
+  public Promise<List<Uint8Array>> getValueAsUint8Arrays() {
+    if (nonNull(getInputElement().element().files)) {
+      return FileUtil.filesToUint8Arrays(getValue());
+    }
+    return Promise.resolve(new ArrayList<>());
+  }
+
+  public Promise<List<byte[]>> getValueAsBytesArrays() {
+    if (nonNull(getInputElement().element().files)) {
+      return FileUtil.filesToByteArrays(getValue());
+    }
+    return Promise.resolve(new ArrayList<>());
+  }
 }

domino-ui/src/main/java/org/dominokit/domino/ui/utils/FileUtil.java

@@ -0,0 +1,85 @@
+/*
+ * Copyright © 2019 Dominokit
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.dominokit.domino.ui.utils;
+
+import elemental2.core.ArrayBuffer;
+import elemental2.core.Uint8Array;
+import elemental2.dom.File;
+import elemental2.promise.Promise;
+import java.util.ArrayList;
+import java.util.List;
+import jsinterop.base.Js;
+
+public class FileUtil {
+
+  public static Promise<Uint8Array> fileToUint8Array(File file) {
+    return file.arrayBuffer()
+        .then(
+            buffer -> {
+              ArrayBuffer ab = Js.uncheckedCast(buffer);
+              return Promise.resolve(new Uint8Array(ab));
+            });
+  }
+
+  public static Promise<byte[]> fileToByteArray(File file) {
+    return fileToUint8Array(file)
+        .then(
+            jsBytes -> {
+              byte[] bytes = new byte[(int) jsBytes.length];
+              for (int i = 0; i < jsBytes.length; i++) {
+                int value = jsBytes.getAt(i).intValue() & 0xFF;
+                bytes[i] = (byte) value;
+              }
+              return Promise.resolve(bytes);
+            });
+  }
+
+  public static Promise<List<Uint8Array>> filesToUint8Arrays(List<File> files) {
+    return filesToUint8Arrays(files, 0, new ArrayList<>());
+  }
+
+  private static Promise<List<Uint8Array>> filesToUint8Arrays(
+      List<File> files, int index, List<Uint8Array> result) {
+    if (index >= files.size()) {
+      return Promise.resolve(result);
+    }
+
+    return fileToUint8Array(files.get(index))
+        .then(
+            bytes -> {
+              result.add(bytes);
+              return filesToUint8Arrays(files, index + 1, result);
+            });
+  }
+
+  public static Promise<List<byte[]>> filesToByteArrays(List<File> files) {
+    return filesToByteArrays(files, 0, new ArrayList<>());
+  }
+
+  private static Promise<List<byte[]>> filesToByteArrays(
+      List<File> files, int index, List<byte[]> result) {
+    if (index >= files.size()) {
+      return Promise.resolve(result);
+    }
+
+    return fileToByteArray(files.get(index))
+        .then(
+            bytes -> {
+              result.add(bytes);
+              return filesToByteArrays(files, index + 1, result);
+            });
+  }
+}