@acorex/platform 20.8.18 → 20.8.19

package/fesm2022/acorex-platform-layout-entity.mjs

@@ -3948,7 +3948,7 @@ class AXPEntityMasterListViewModel {
                 this.events$.next({ action: 'refresh' });
             }
         });
-        this.sortedFields.set(this.sortableFields());
+        this.sortedFields.set([]);
         void this.syncShowRowIndexColumnSetting();
         this.settings.onLoaded.pipe(takeUntil(this.destroyed)).subscribe(() => {
             void this.syncShowRowIndexColumnSetting();
@@ -4051,10 +4051,8 @@ class AXPEntityMasterListViewModel {
                     .sort((a, b) => columns.findIndex((col) => col.name === (a.column?.options?.dataPath ?? a.name)) -
                     columns.findIndex((col) => col.name === (b.column?.options?.dataPath ?? b.name))));
             }
-            if (Array.isArray(sorts)) {
-                // sorts are AXPSortQuery[]; ensure we map by name
-                const sortsMap = new Map(sorts.map((s) => [s.name, s.dir]));
-                this.sortedFields.update((prev) => prev.map((sf) => ({ ...sf, dir: sortsMap.get(sf.name) || sf.dir })));
+            if (Array.isArray(sorts) && sorts.length) {
+                this.setActiveSortsFromQueries(sorts);
             }
             // Don't override filters if they came from queryParams
             if (Array.isArray(filters) && !this.hasQueryParamsFilters) {
@@ -4569,18 +4567,80 @@ class AXPEntityMasterListViewModel {
     resetSorts() {
         this.applyViewSorts();
     }
+    /**
+     * Applies active sorts in the given order (click order, saved settings, or view defaults).
+     */
+    setActiveSortsFromQueries(sorts) {
+        const sortableByName = new Map(this.sortableFields().map((f) => [f.name, f]));
+        this.sortedFields.set(sorts
+            .filter((s) => s.dir && sortableByName.has(s.name))
+            .map((s) => ({
+            name: s.name,
+            title: sortableByName.get(s.name).title,
+            dir: s.dir,
+        })));
+    }
     applyViewSorts() {
-        const viewSorts = this.view().sorts;
-        this.sortedFields.update((prev) => {
-            const viewSortsMap = new Map(viewSorts.map((vs) => [vs.name, vs]));
-            return prev.map((sf) => {
-                const updatedSort = viewSortsMap.get(sf.name);
-                if (updatedSort) {
-                    return { ...updatedSort, title: sf.title };
-                }
-                return sf;
-            });
-        });
+        const viewSorts = this.view().sorts ?? [];
+        this.setActiveSortsFromQueries(viewSorts);
+    }
+    /**
+     * Active sort direction for a column (synced with toolbar sort UI and dataSource).
+     */
+    getColumnSortDirection(columnName) {
+        const dir = this.sortedFields().find((sf) => sf.name === columnName)?.dir;
+        return dir === 'asc' || dir === 'desc' ? dir : undefined;
+    }
+    /**
+     * 1-based priority index when multiple columns are sorted (Ctrl+click order).
+     */
+    getColumnSortIndex(columnName) {
+        const index = this.sortedFields().findIndex((sf) => sf.name === columnName);
+        return index >= 0 ? index + 1 : undefined;
+    }
+    /** True when active sorts still match the current view defaults (not yet customized). */
+    isViewDefaultSorts(activeSorts) {
+        const viewSorts = this.view().sorts ?? [];
+        if (activeSorts.length !== viewSorts.length) {
+            return false;
+        }
+        return activeSorts.every((s, i) => s.name === viewSorts[i]?.name && s.dir === viewSorts[i]?.dir);
+    }
+    /**
+     * Toggles column sort (asc → desc → none). Without Ctrl, only one column is active.
+     * With Ctrl/Cmd, multiple columns are sorted in click order (first clicked = primary).
+     */
+    async toggleColumnSort(columnName, multiSort) {
+        const fieldMeta = this.sortableFields().find((f) => f.name === columnName);
+        if (!fieldMeta) {
+            return;
+        }
+        let activeSorts = [...this.sortedFields()];
+        const index = activeSorts.findIndex((sf) => sf.name === columnName);
+        const currentDir = index >= 0 ? activeSorts[index].dir : undefined;
+        const newDir = currentDir === 'asc' ? 'desc' : currentDir === 'desc' ? undefined : 'asc';
+        if (!multiSort) {
+            activeSorts = newDir ? [{ name: columnName, title: fieldMeta.title, dir: newDir }] : [];
+        }
+        else if (index >= 0) {
+            const [item] = activeSorts.splice(index, 1);
+            if (newDir) {
+                // Re-click moves column to end so click order can override view/default order.
+                activeSorts.push({ ...item, title: fieldMeta.title, dir: newDir });
+            }
+        }
+        else if (newDir) {
+            if (this.isViewDefaultSorts(activeSorts)) {
+                activeSorts = [{ name: columnName, title: fieldMeta.title, dir: newDir }];
+            }
+            else {
+                activeSorts.push({ name: columnName, title: fieldMeta.title, dir: newDir });
+            }
+        }
+        this.sortedFields.set(activeSorts);
+        this.lastAppliedSortKey = null;
+        await this.saveSettings('sorts', activeSorts.map((s) => ({ name: s.name, dir: s.dir })));
+        await this.applyFilterAndSort();
     }
     //******************  Commands ******************//
     async executeCommand(commandName, data = null) {