@den4ik92/ng2-smart-table 19.2.6 → 19.2.8

package/fesm2022/den4ik92-ng2-smart-table.mjs

@@ -175,6 +175,13 @@ function getLocalStorage(key) {
         return null;
     }
 }
+function promiseDelay(time) {
+    return new Promise((resolve) => {
+        setTimeout(() => {
+            resolve();
+        }, time);
+    });
+}
 
 class TableColumnsEditorComponent {
     constructor() {
@@ -494,31 +501,31 @@ class DataSource {
     onChanged() {
         return this.onChangedSource.asObservable();
     }
-    prepend(element) {
+    async prepend(element) {
         this.data.update((old) => [element, ...old]);
         this.emitOnChanged({ action: SmartTableOnChangedEventName.prepend, newItems: [element] });
         return Promise.resolve(true);
     }
-    appendMany(elements) {
+    async appendMany(elements) {
         this.data.update((old) => [...old, ...elements,]);
         this.emitOnChanged({ action: SmartTableOnChangedEventName.appendMany, newItems: elements });
         return Promise.resolve(true);
     }
-    add(element) {
+    async add(element) {
         this.data.update((old) => [...old, element,]);
         this.emitOnChanged({ action: SmartTableOnChangedEventName.add, newItems: [element] });
         return Promise.resolve(true);
     }
-    remove(element) {
+    async remove(element) {
         this.data.update((old) => old.filter((el) => el !== element));
         this.emitOnChanged({ action: SmartTableOnChangedEventName.remove, item: element });
         return Promise.resolve(true);
     }
-    update(oldItem, newItem) {
+    async update(oldItem, newItem) {
         this.emitOnChanged({ action: SmartTableOnChangedEventName.update, oldItem, newItem });
         return Promise.resolve(true);
     }
-    empty() {
+    async empty() {
         this.data.set([]);
         this.emitOnChanged({ action: SmartTableOnChangedEventName.empty });
         return Promise.resolve(true);
@@ -530,7 +537,7 @@ class DataSource {
             this.emitOnChanged({ action: SmartTableOnChangedEventName.sort });
         }
     }
-    addFilter(newFilter, doEmit = true) {
+    async addFilter(newFilter, doEmit = true) {
         if (!newFilter.field) {
             return;
         }
@@ -590,7 +597,7 @@ class DataSource {
 function filterValues(value, search) {
     return value.toString().toLowerCase().includes(search.toString().toLowerCase());
 }
-function isElementSatisfied(element, filters) {
+async function isElementSatisfied(element, filters) {
     return filters.every((filter) => {
         if (!filter.search?.length) {
             return true;
@@ -620,7 +627,7 @@ function compareValues(direction, a, b) {
     return 0;
 }
 class LocalSorter {
-    static sort(data, field, direction, customCompare) {
+    static async sort(data, field, direction, customCompare) {
         const dir = direction === "asc" ? 1 : -1;
         const compare = customCompare ? customCompare : compareValues;
         return data.sort((a, b) => {
@@ -636,9 +643,9 @@ class LocalDataSource extends DataSource {
         this.count = computed(() => this.filteredAndSorted().length);
         this.data.set(data);
     }
-    load(data) {
+    async load(data) {
         this.data.set(data);
-        this.emitOnChanged({ action: SmartTableOnChangedEventName.load });
+        this.emitOnChanged({ action: SmartTableOnChangedEventName.load }, data);
         return Promise.resolve(true);
     }
     prepend(element) {
@@ -677,17 +684,17 @@ class LocalDataSource extends DataSource {
     getFilters() {
         return this.filters;
     }
-    emitOnChanged(event) {
-        let renderData = this.filteredAndSorted();
+    async emitOnChanged(event, newElements) {
+        let renderData = this.filteredAndSorted().slice(0);
         const action = event.action;
         if (['filter', 'refresh', 'load', 'add', 'prepend', 'appendMany'].includes(action)) {
-            renderData = this.filter(this.data().slice(0));
-            this.filteredAndSorted.set(this.sort(renderData));
-            renderData = this.filteredAndSorted();
+            renderData = await this.filter(newElements || this.data().slice(0));
+            renderData = await this.sort(renderData);
+            this.filteredAndSorted.set(renderData);
         }
-        if (['sort', 'filter', 'refresh', 'load'].includes(action)) {
-            this.filteredAndSorted.update((list) => this.sort(list));
-            renderData = this.filteredAndSorted();
+        if (action === SmartTableOnChangedEventName.sort) {
+            renderData = await this.sort(renderData);
+            this.filteredAndSorted.set(renderData);
         }
         if (this.pagingConf().display &&
             ['page', 'paging', 'refresh', 'load', 'sort', 'filter'].includes(action)) {
@@ -698,19 +705,23 @@ class LocalDataSource extends DataSource {
             this.setPage(this.pagingConf().page - 1);
         }
     }
-    sort(data) {
+    async sort(data) {
         if (this.sortConf) {
-            data = LocalSorter.sort(data, this.sortConf.field, this.sortConf.direction, this.sortConf.compare);
+            return LocalSorter.sort(data, this.sortConf.field, this.sortConf.direction, this.sortConf.compare);
         }
         return data;
     }
-    filter(data) {
-        if (this.filters.length > 0) {
-            return data.filter((item) => {
-                return isElementSatisfied(item, this.filters);
-            });
+    async filter(data) {
+        if (!this.filters.length) {
+            return data;
         }
-        return data;
+        const filtered = [];
+        await Promise.all(data.map(async (element) => {
+            if (await isElementSatisfied(element, this.filters)) {
+                filtered.push(element);
+            }
+        }));
+        return filtered;
     }
     paginate(data) {
         if (this.pagingConf().display) {