@sumaris-net/ngx-components 1.5.6 → 1.5.10

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

@@ -523,53 +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 res = {
-            total: target.length || 0,
-            data: undefined // will be below
-        };
-        // Page (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) {
-                res.data = target.slice(opts.offset);
+            if ((opts.offset || 0) > 0) {
+                pageData = pageData.slice(opts.offset);
             }
-            if (isNotNil(opts.size) && target.length > opts.size) {
-                res.data = target.slice(0, opts.size);
+            if (isNotNil(opts.size) && pageData.length > opts.size) {
+                pageData = pageData.slice(0, opts.size);
             }
         }
-        else {
-            res.data = target;
-        }
+        var result = {
+            data: pageData,
+            total: total
+        };
         // Add fetch more capability, if total was fetched
-        var nextOffset = (opts && opts.offset || 0) + target.length;
-        if (nextOffset < res.total) {
-            res.fetchMore = function (_) { return __awaiter(_this, void 0, void 0, function () {
+        var nextOffset = (opts && opts.offset || 0) + pageData.length;
+        if (nextOffset < total) {
+            result.fetchMore = function (_) { return __awaiter(_this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
-                    return [2 /*return*/, suggestFromArray(target, undefined /*already applied*/, Object.assign(Object.assign({}, opts), { offset: nextOffset, excludedIds: undefined // not need (already applied)
+                    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;
@@ -24889,8 +24892,10 @@
          * @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;
+                var _this = this;
                 return __generator(this, function (_d) {
                     switch (_d.label) {
                         case 0:
@@ -24904,15 +24909,29 @@
                                 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();
                             if (!canDelete)
                                 return [2 /*return*/, 0]; // Cannot delete
                             if (!this.saveBeforeDelete) return [3 /*break*/, 3];
-                            // Cancel invalid rows (because of save() will failed if there is invalid rows)
+                            // Cancel invalid rows (because of save() will fail, if invalid rows exists)
                             rows.filter(function (row) { var _a; return !((_a = row.validator) === null || _a === void 0 ? void 0 : _a.valid); })
-                                .forEach(function (row) { return row.cancelOrDelete(); });
+                                .forEach(function (row) {
+                                var deleted = row.id === -1;
+                                row.cancelOrDelete();
+                                // When deleted (= newly created row) : decrement counter
+                                if (deleted) {
+                                    _this.visibleRowCount--;
+                                    _this.totalRowCount--;
+                                }
+                            });
                             return [4 /*yield*/, this.saveBeforeAction('delete')];
                         case 2:
                             saved = _d.sent();
@@ -24936,7 +24955,7 @@
                             return [4 /*yield*/, this._dataSource.deleteAll(rowsToDelete)];
                         case 5:
                             _d.sent();
-                            // Not need to update manually, because watchALl().subscribe() will update this count
+                            // DO not update manually, because watchALl().subscribe() will update this count
                             //this.totalRowCount -= deleteCount;
                             //this.visibleRowCount -= deleteCount;
                             this.selection.clear();