@masterteam/work-center 0.0.62 → 0.0.64

package/fesm2022/masterteam-work-center.mjs

@@ -168,6 +168,22 @@ class ApplyColumnFilters {
         this.filters = filters;
     }
 }
+/**
+ * Switches the selected card and drops everything that was scoped to the
+ * previous one: advanced filters, in-table column filters, grouping and the
+ * sort that grouping implied. Each card brings its own columns and filter
+ * schema, so carrying those over would filter on fields the new card doesn't
+ * have and group by a column it doesn't show.
+ */
+class SelectCard {
+    area;
+    selectedCardKey;
+    static type = '[WorkCenter] Select Card';
+    constructor(area, selectedCardKey) {
+        this.area = area;
+        this.selectedCardKey = selectedCardKey;
+    }
+}
 /**
  * Sets the grouped column. Grouping is expressed to the backend as a single
  * sort on the same field, so this also rewrites `context.sort` and resets
@@ -220,6 +236,13 @@ const WORK_CENTER_LEVEL_NAME_KEY = 'levelDataName';
 const WORK_CENTER_LEVEL_GROUP_FIELD = '__mtLevelGroup';
 /** Rendered in place of a missing / restricted LevelData label. */
 const WORK_CENTER_EMPTY_LABEL = '—';
+/**
+ * Bootstrap `group` value meaning "the user turned grouping off". Needed
+ * because an absent `group` means "not chosen yet" and falls back to the
+ * default grouping — without a distinct value, clearing the group would be
+ * undone by the next navigation.
+ */
+const WORK_CENTER_GROUP_NONE = 'none';
 
 const AREA_COLORS = ['violet', 'blue', 'emerald', 'amber', 'teal'];
 /** Fallback accent rotation used only when the backend sends no stat color. */
@@ -306,15 +329,30 @@ function parseSortInput(value) {
         : [];
 }
 /**
- * Resolves the grouped column key from bootstrap inputs. Mirrors the `sort`
- * rules: a present value wins, an explicit `null` clears, `undefined` keeps
- * whatever is already in state.
+ * Resolves the grouped column key from bootstrap inputs.
+ *
+ * A missing `group` keeps whatever state already has, so an unrelated
+ * navigation doesn't drop the user's grouping. `WORK_CENTER_GROUP_NONE` is the
+ * only way to express "turn it off" — a bare `null` can't, because it is also
+ * what a host passes for an absent query param.
  */
 function resolveGroupByFromInputs(current, group) {
-    if (hasParamValue(group)) {
-        return typeof group === 'string' ? group.trim() || null : null;
+    if (!hasParamValue(group) || typeof group !== 'string') {
+        return current;
+    }
+    const parsed = group.trim();
+    if (!parsed || parsed === WORK_CENTER_GROUP_NONE) {
+        return null;
     }
-    return group === null ? null : current;
+    return parsed;
+}
+/**
+ * The card these inputs resolve to — the same rule `buildContextFromInputs`
+ * applies, exposed so callers can detect a card switch before building the
+ * context (what survives the switch depends on it).
+ */
+function resolveSelectedCardKeyFromInputs(currentContext, inputs = {}) {
+    return toSelectedCardKey(inputs.card) ?? currentContext.selectedCardKey;
 }
 function parseFiltersInput(value) {
     const parsed = parseJson(value);
@@ -543,6 +581,10 @@ function buildKpis(stats, fallbackIcon) {
         color: stat.color?.trim() || KPI_COLORS[index % KPI_COLORS.length],
     }));
 }
+/** The backend sort that renders a grouped column as contiguous rows. */
+function sortForGroup(groupBy) {
+    return groupBy ? [{ field: groupBy, dir: 'asc' }] : [];
+}
 function createDefaultContext(area) {
     return {
         area,
@@ -611,7 +653,14 @@ function normalizeContext(context) {
         runtimeFilters: sanitizeFilters(context.runtimeFilters),
     };
 }
-function buildContextFromInputs(currentContext, area, inputs = {}) {
+function buildContextFromInputs(currentContext, area, inputs = {}, 
+/**
+ * Already-resolved grouped column. Grouping is executed as a backend sort,
+ * so when the host supplies no explicit `sort` the grouped column defines
+ * it — that is what makes the default grouping reach the very first request
+ * instead of costing a second round trip.
+ */
+groupBy = null) {
     const parsedCardKey = toSelectedCardKey(inputs.card);
     const parsedTemplateId = toOptionalInt(inputs.templateId);
     const parsedLevelDataId = toOptionalInt(inputs.levelDataId);
@@ -628,9 +677,11 @@ function buildContextFromInputs(currentContext, area, inputs = {}) {
         levelDataId: parsedLevelDataId ?? currentContext.levelDataId,
         sort: hasParamValue(inputs.sort)
             ? parseSortInput(inputs.sort)
-            : inputs.sort === null
-                ? []
-                : currentContext.sort,
+            : groupBy
+                ? sortForGroup(groupBy)
+                : inputs.sort === null
+                    ? []
+                    : currentContext.sort,
         runtimeFilters: hasParamValue(inputs.filters)
             ? parseFiltersInput(inputs.filters)
             : inputs.filters === null
@@ -664,8 +715,20 @@ function mapRuntimeResponse(current, response) {
     const columns = buildColumns(selectedCard?.columnsConfig ?? selectedCardFromList?.columnsConfig);
     const rows = toDisplayRows(selectedCard?.items ?? [], columns);
     const kpis = buildKpis(selectedCard?.stats ?? [], selectedMenuItem?.icon ?? null);
+    // A card that doesn't advertise the grouped column can't be grouped by it —
+    // drop it here rather than letting the table discover the stale column and
+    // bounce a second request. The sort goes with it when it was the one the
+    // grouping asked for.
+    const groupBy = current.groupBy && columns.some((column) => column.key === current.groupBy)
+        ? current.groupBy
+        : null;
+    const droppedGroup = !groupBy && current.groupBy;
+    const sort = droppedGroup && isSortForGroup(current.context.sort, current.groupBy)
+        ? []
+        : current.context.sort;
     return {
         ...current,
+        groupBy,
         menuItems,
         rows,
         columns,
@@ -679,11 +742,16 @@ function mapRuntimeResponse(current, response) {
         context: {
             ...current.context,
             selectedCardKey,
+            sort,
             page: selectedCard?.pagination.page ?? current.context.page,
             pageSize: selectedCard?.pagination.pageSize ?? current.context.pageSize,
         },
     };
 }
+/** True when `sort` is exactly the single rule a grouping would produce. */
+function isSortForGroup(sort, groupBy) {
+    return !!groupBy && sort.length === 1 && sort[0].field === groupBy;
+}
 
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -784,8 +852,19 @@ let WorkCenterState = class WorkCenterState {
     setParams(ctx, action) {
         const state = ctx.getState();
         const current = state.byArea[action.area];
-        const nextContext = buildContextFromInputs(current.context, action.area, action.inputs);
-        const nextGroupBy = resolveGroupByFromInputs(current.groupBy, action.inputs?.group);
+        // A card switch invalidates everything scoped to the previous card. The
+        // host usually drops those query params too, but a stale URL must not be
+        // able to re-apply a filter on a field the new card doesn't have.
+        const cardChanged = resolveSelectedCardKeyFromInputs(current.context, action.inputs) !==
+            current.context.selectedCardKey;
+        // Resolve grouping first: with no explicit `sort` input it is what defines
+        // the backend sort.
+        const nextGroupBy = resolveGroupByFromInputs(cardChanged ? null : current.groupBy, action.inputs?.group);
+        const builtContext = buildContextFromInputs(current.context, action.area, action.inputs, nextGroupBy);
+        const filtersFromInputs = action.inputs?.filters !== undefined;
+        const nextContext = cardChanged && !filtersFromInputs
+            ? { ...builtContext, runtimeFilters: [] }
+            : builtContext;
         const areaChanged = state.activeArea !== action.area;
         const contextChanged = !isSameContext(current.context, nextContext);
         const groupChanged = nextGroupBy !== current.groupBy;
@@ -795,11 +874,12 @@ let WorkCenterState = class WorkCenterState {
             // URL-derived filters land on the header slice. Anything previously
             // applied via the in-table column filters is dropped so the BE payload
             // matches what the user sees on the page header.
-            const filtersFromInputs = action.inputs?.filters !== undefined;
             const nextHeaderFilters = filtersFromInputs
                 ? nextContext.runtimeFilters
-                : current.headerFilters;
-            const nextColumnFilters = filtersFromInputs ? [] : current.columnFilters;
+                : cardChanged
+                    ? []
+                    : current.headerFilters;
+            const nextColumnFilters = filtersFromInputs || cardChanged ? [] : current.columnFilters;
             ctx.patchState({
                 activeArea: action.area,
                 byArea: {
@@ -836,6 +916,33 @@ let WorkCenterState = class WorkCenterState {
             columnFilters: action.filters,
         });
     }
+    selectCard(ctx, action) {
+        const state = ctx.getState();
+        const current = state.byArea[action.area];
+        if (current.context.selectedCardKey === action.selectedCardKey) {
+            return;
+        }
+        ctx.patchState({
+            activeArea: action.area,
+            byArea: {
+                ...state.byArea,
+                [action.area]: {
+                    ...current,
+                    headerFilters: [],
+                    columnFilters: [],
+                    groupBy: null,
+                    context: {
+                        ...current.context,
+                        selectedCardKey: action.selectedCardKey,
+                        runtimeFilters: [],
+                        sort: [],
+                        page: 1,
+                    },
+                },
+            },
+        });
+        return ctx.dispatch(new LoadRuntime(action.area, 'menu-change'));
+    }
     /**
      * Grouping is a backend concern: the table only renders contiguous rows, so
      * the grouped column is pushed down as the single `context.sort` entry and
@@ -974,6 +1081,9 @@ __decorate([
 __decorate([
     Action(ApplyColumnFilters)
 ], WorkCenterState.prototype, "applyColumnFilters", null);
+__decorate([
+    Action(SelectCard)
+], WorkCenterState.prototype, "selectCard", null);
 __decorate([
     Action(SetGroupBy)
 ], WorkCenterState.prototype, "setGroupBy", null);
@@ -1042,7 +1152,7 @@ WorkCenterState = __decorate([
 ], WorkCenterState);
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: WorkCenterState, decorators: [{
             type: Injectable
-        }], propDecorators: { enterArea: [], hydrateFromContext: [], setParams: [], setLookups: [], applyHeaderFilters: [], applyColumnFilters: [], setGroupBy: [], clearAllFilters: [], loadRuntime: [] } });
+        }], propDecorators: { enterArea: [], hydrateFromContext: [], setParams: [], setLookups: [], applyHeaderFilters: [], applyColumnFilters: [], selectCard: [], setGroupBy: [], clearAllFilters: [], loadRuntime: [] } });
 
 class WorkCenterFacade {
     store = inject(Store);
@@ -1086,11 +1196,12 @@ class WorkCenterFacade {
     setLookups(lookups) {
         return this.store.dispatch(new SetLookups(lookups));
     }
+    /**
+     * Switches card and drops the previous card's filters, grouping and sort —
+     * each card has its own columns and filter schema.
+     */
     selectCardAndLoad(area, selectedCardKey) {
-        return this.store.dispatch([
-            new HydrateFromContext(area, { selectedCardKey, page: 1 }),
-            new LoadRuntime(area, 'menu-change'),
-        ]);
+        return this.store.dispatch(new SelectCard(area, selectedCardKey));
     }
     applyTableLazyLoadAndLoad(area, event) {
         const context = this.store.selectSnapshot(WorkCenterState.context);
@@ -3012,8 +3123,13 @@ class WorkCenterPage {
         if (item.key === this.context().selectedCardKey) {
             return;
         }
+        // The store drops the previous card's filters and grouping; the table's
+        // own filter chips live here, so they have to be cleared alongside.
+        this.tableFilters.set({});
         this.facade.selectCardAndLoad(this.area(), item.key);
         this.cardSelected.emit(item.key);
+        this.groupChanged.emit(null);
+        this.sortChanged.emit([]);
     }
     onRuntimeFiltersApplied(filters) {
         const mappedFilters = filters.map((filter) => ({
@@ -3189,5 +3305,5 @@ const APP_STATES = [WorkCenterState];
  * Generated bundle index. Do not edit.
  */
 
-export { APP_STATES, ApplyColumnFilters, ApplyHeaderFilters, ClearAllFilters, EnterArea, HydrateFromContext, LoadRuntime, SetGroupBy, SetLookups, SetParams, WORK_CENTER_EMPTY_LABEL, WORK_CENTER_LEVEL_GROUP_FIELD, WORK_CENTER_LEVEL_NAME_KEY, WORK_CENTER_MAX_FILTERS, WORK_CENTER_MAX_PAGE_SIZE, WORK_CENTER_MAX_SORT, WORK_CENTER_QUERY_VERSION, WorkCenterActionKey, WorkCenterClientFormModal, WorkCenterFacade, WorkCenterItemModal, WorkCenterItemModalRoute, WorkCenterPage, WorkCenterState, decodeWorkCenterRouteContextKey, encodeWorkCenterRouteContextKey };
+export { APP_STATES, ApplyColumnFilters, ApplyHeaderFilters, ClearAllFilters, EnterArea, HydrateFromContext, LoadRuntime, SelectCard, SetGroupBy, SetLookups, SetParams, WORK_CENTER_EMPTY_LABEL, WORK_CENTER_GROUP_NONE, WORK_CENTER_LEVEL_GROUP_FIELD, WORK_CENTER_LEVEL_NAME_KEY, WORK_CENTER_MAX_FILTERS, WORK_CENTER_MAX_PAGE_SIZE, WORK_CENTER_MAX_SORT, WORK_CENTER_QUERY_VERSION, WorkCenterActionKey, WorkCenterClientFormModal, WorkCenterFacade, WorkCenterItemModal, WorkCenterItemModalRoute, WorkCenterPage, WorkCenterState, decodeWorkCenterRouteContextKey, encodeWorkCenterRouteContextKey };
 //# sourceMappingURL=masterteam-work-center.mjs.map