@sumaris-net/ngx-components 1.5.5 → 1.5.9

package/bundles/sumaris-net.ngx-components.umd.js

@@ -523,48 +523,56 @@
             return { data: [], total: 0 };
         }
         // Filter items
-        var target = items;
+        var filteredItems = items;
         if (isNotNilOrBlank(value)) {
             // If wildcard, search using regexp
             if (value.indexOf('*') !== -1) {
                 value = value.replace('*', '.*');
-                target = target.filter(function (v) { return keys.findIndex(function (key) { return matchUpperCase(getPropertyByPathAsString(v, key), value); }) !== -1; });
+                filteredItems = filteredItems.filter(function (v) { return keys.findIndex(function (key) { return matchUpperCase(getPropertyByPathAsString(v, key), value); }) !== -1; });
             }
             // Else (no wildcard), search using startsWith
             else {
-                target = target.filter(function (v) { return keys.findIndex(function (key) { return startsWithUpperCase(getPropertyByPathAsString(v, key), value); }) !== -1; });
+                filteredItems = filteredItems.filter(function (v) { return keys.findIndex(function (key) { return startsWithUpperCase(getPropertyByPathAsString(v, key), value); }) !== -1; });
             }
         }
         // Exclude ids
         if (isNotEmptyArray(opts === null || opts === void 0 ? void 0 : opts.excludedIds)) {
-            target = target.filter(function (v) { return !opts.excludedIds.includes(+v['id']); });
-        }
-        // Sort (copy if need, before sorting)
-        if (target === items)
-            target = target.slice();
-        target.sort(propertiesPathComparator(keys));
-        var total = items.length || 0;
-        // Truncate if need
+            filteredItems = filteredItems.filter(function (v) { return !opts.excludedIds.includes(+v['id']); });
+        }
+        // Sort
+        if (!opts || opts.skipSort !== true) {
+            // Make to copy input items, before sorting (if not yet already done)
+            if (filteredItems === items)
+                filteredItems = filteredItems.slice();
+            // Sort by keys
+            filteredItems.sort(propertiesPathComparator(keys));
+        }
+        var total = filteredItems.length || 0;
+        // Pagination (truncate if need)
+        var pageData = filteredItems;
         if (opts) {
-            if (isNil(opts.offset) && opts.offset > 0) {
-                target = target.slice(opts.offset);
+            if ((opts.offset || 0) > 0) {
+                pageData = pageData.slice(opts.offset);
             }
-            if (isNotNil(opts.size) && target.length > opts.size) {
-                target = target.slice(0, opts.size);
+            if (isNotNil(opts.size) && pageData.length > opts.size) {
+                pageData = pageData.slice(0, opts.size);
             }
         }
-        var res = {
-            data: target,
+        var result = {
+            data: pageData,
             total: total
         };
         // Add fetch more capability, if total was fetched
-        var nextOffset = (opts && opts.offset || 0) + items.length;
+        var nextOffset = (opts && opts.offset || 0) + pageData.length;
         if (nextOffset < total) {
-            res.fetchMore = function (_) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
-                return [2 /*return*/, suggestFromArray(items, value, Object.assign({ offset: nextOffset }, opts))];
-            }); }); };
+            result.fetchMore = function (_) { return __awaiter(_this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, suggestFromArray(filteredItems, undefined /*OPTIMISATION: already applied*/, Object.assign(Object.assign({}, opts), { offset: nextOffset, skipSort: true, excludedIds: undefined // OPTIMISATION: already filtered
+                        }))];
+                });
+            }); };
         }
-        return res;
+        return result;
     }
     function suggestFromStringArray(values, value, options) {
         value = (typeof value === 'string' && value !== '*') && value.toUpperCase() || undefined;
@@ -24884,8 +24892,9 @@
          * @param opts Use interactive=false to avoid user interaction (e.g. user confirmation)
          */
         AppTable.prototype.deleteRows = function (event, rows, opts) {
+            var _a;
             return __awaiter(this, void 0, void 0, function () {
-                var canDelete, saved, rowsToDelete, deleteCount, err_2;
+                var confirmed, canDelete, saved, rowsToDelete, deleteCount, err_2;
                 return __generator(this, function (_d) {
                     switch (_d.label) {
                         case 0:
@@ -24899,6 +24908,12 @@
                                 return [2 /*return*/, 0];
                             if (this.loading || isEmptyArray(rows))
                                 return [2 /*return*/, 0];
+                            // Make sure to keep newly created row
+                            if (((_a = this.editedRow) === null || _a === void 0 ? void 0 : _a.id) === -1 && this.editedRow.editing && !rows.includes(this.editedRow)) {
+                                confirmed = this.confirmEditCreate();
+                                if (!confirmed)
+                                    return [2 /*return*/, 0]; // Cannot delete (e.g. edited row is invalid)
+                            }
                             return [4 /*yield*/, this.canDeleteRows(rows, opts)];
                         case 1:
                             canDelete = _d.sent();
@@ -24931,9 +24946,10 @@
                             return [4 /*yield*/, this._dataSource.deleteAll(rowsToDelete)];
                         case 5:
                             _d.sent();
-                            // Not need to update manually, because watchALl().subscribe() will update this count
-                            //this.totalRowCount -= deleteCount;
-                            //this.visibleRowCount -= deleteCount;
+                            // Update manually, even if watchALl().subscribe() will update this count,
+                            // because of memory data service (see issue #
+                            this.totalRowCount -= deleteCount;
+                            this.visibleRowCount -= deleteCount;
                             this.selection.clear();
                             this.editedRow = undefined;
                             this.markAsDirty({ emitEvent: false /*markForCheck() is called just after*/ });