@masterteam/client-components 0.0.86 → 0.0.87

package/fesm2022/masterteam-client-components-client-list.mjs

@@ -559,8 +559,6 @@ class ClientListStateService {
             existing.areaType !== item.areaType) {
             return item;
         }
-        const keepPaging = existing.config.isPaginated === item.config.isPaginated &&
-            existing.take === item.take;
         return {
             ...item,
             loading: existing.loading,
@@ -571,7 +569,12 @@ class ClientListStateService {
             columns: existing.columns,
             rows: existing.rows,
             cards: existing.cards,
-            skip: keepPaging ? existing.skip : item.skip,
+            // Paging is settled by the caller, which compared the incoming config
+            // against the previous one. Re-deciding it here — with only the two
+            // states and no view of what changed in the config — is what used to
+            // drop the user's page whenever their rows-per-page differed from the
+            // configured default.
+            skip: item.skip,
             take: item.take,
             expanded: existing.expanded,
             dashboardData: existing.dashboardData,
@@ -1941,6 +1944,40 @@ function toScalar(value) {
         item['displayName']);
 }
 
+/**
+ * Whether the offset a list is currently sitting on still describes the same
+ * result set, i.e. this reconfigure changed nothing about what gets fetched.
+ *
+ * Hosts rebuild the `configurations` array from a `computed()`, so *any*
+ * unrelated state change — a permission refresh after a write, a language
+ * switch, a re-rendered header template — hands the list a brand new array
+ * with identical content. That must not move the user off their page, and
+ * must not cost a request.
+ *
+ * The page size is compared **as configured**, never as currently applied. The
+ * table owns its rows-per-page: the user picks it from the paginator and
+ * `mt-table` restores a persisted value, and either of those legitimately
+ * leaves the runtime `take` different from the configured one. Reading that
+ * difference as drift to correct is what used to reset the paginator and
+ * refetch page 1 on every reconfigure.
+ */
+function preservesPaging(existing, areaType, next) {
+    if (!existing ||
+        existing.type !== 'form' ||
+        existing.areaType !== areaType ||
+        next.type !== 'form') {
+        return false;
+    }
+    const current = existing.config;
+    return (current.isPaginated === next.isPaginated &&
+        current.take === next.take &&
+        current.contextKey === next.contextKey &&
+        serializeFilters(current.filters) === serializeFilters(next.filters));
+}
+function serializeFilters(filters) {
+    return JSON.stringify(filters ?? []);
+}
+
 const DEFAULT_AREA_TYPE = 'table';
 const DEFAULT_MODE = 'auto';
 const DEFAULT_TYPE = 'form';
@@ -2546,6 +2583,10 @@ class ClientList {
             const key = config.key ?? this.createItemKey(config, index);
             const existing = previousItems[key];
             const normalizedConfig = this.toNormalizedConfig(config, type, areaType, mode, isPaginated, take, showHeader, collapseEnabled, layout);
+            // Paging is runtime state, not config state: it survives a reconfigure
+            // that changed nothing about the fetch, and the *applied* page size
+            // (the user's rows-per-page choice) is carried forward with it.
+            const keepsPaging = preservesPaging(existing, areaType, normalizedConfig);
             if (isInformative) {
                 return {
                     key,
@@ -2581,12 +2622,13 @@ class ClientList {
                     columns: [],
                     rows: [],
                     cards: [],
-                    // Cards restart from the first page on every reconfigure: the
-                    // loaded set above is wiped, and for infinite scroll `skip` is
-                    // the next offset into that set — carrying it forward would ask
-                    // the backend for page N with nothing before it on screen.
-                    skip: 0,
-                    take,
+                    // For infinite scroll `skip` is the next offset into the loaded
+                    // set, so it travels with that set: kept while the fetch is
+                    // unchanged (the cards themselves are kept too, by
+                    // `mergeItemState`), and restarted at 0 the moment the fetch
+                    // changes and the loaded set stops meaning anything.
+                    skip: keepsPaging ? existing.skip : 0,
+                    take: keepsPaging ? existing.take : take,
                     expanded: existing?.expanded ?? config.collapse?.expandedByDefault ?? true,
                     dashboardData: null,
                     rawData: existing?.rawData ?? null,
@@ -2605,12 +2647,8 @@ class ClientList {
                 columns: [],
                 rows: [],
                 cards: [],
-                skip: existing?.areaType === 'table' &&
-                    existing.config.isPaginated === isPaginated &&
-                    existing.take === take
-                    ? existing.skip
-                    : 0,
-                take,
+                skip: keepsPaging ? existing.skip : 0,
+                take: keepsPaging ? existing.take : take,
                 expanded: existing?.expanded ?? config.collapse?.expandedByDefault ?? true,
                 dashboardData: null,
                 rawData: existing?.rawData ?? null,