@akcelik/strct 5.8.0 → 5.9.0

package/fesm2022/akcelik-strct.mjs

@@ -14493,7 +14493,7 @@ class StrctDatagrid {
         const sortRows = (rs) => {
             const c = [...rs];
             if (key)
-                c.sort((a, b) => sign * this.compare(a[key], b[key]));
+                c.sort((a, b) => this.compareRows(a, b, key, sign));
             return c;
         };
         const filtering = this.activeFilters().length > 0 || this.quickTerm() !== '';
@@ -14527,7 +14527,7 @@ class StrctDatagrid {
         if (!key)
             return data;
         const sign = dir === 'asc' ? 1 : -1;
-        return data.sort((a, b) => sign * this.compare(a[key], b[key]));
+        return data.sort((a, b) => this.compareRows(a, b, key, sign));
     }, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "sorted" }] : /* istanbul ignore next */ []));
     paged = computed(() => {
@@ -14942,6 +14942,12 @@ class StrctDatagrid {
                 this.lazyLoad.emit(state);
             });
         });
+        // The columns' own `hidden` flags, read once they exist — a required input
+        // is not available in the constructor.
+        effect(() => {
+            const cols = this.columns();
+            untracked(() => this.applyDeclaredHidden(cols));
+        });
         // Restore persisted column preferences once, before the first render.
         const persisted = this.readPersistedState();
         if (persisted)
@@ -14961,7 +14967,10 @@ class StrctDatagrid {
             const widths = Object.fromEntries(this.columnWidths());
             const hidden = [...this.hiddenColumns()];
             const order = this.columnOrder() ?? undefined;
-            const st = { widths, hidden, order };
+            // A list an operator sorted by Host CPU opened sorted by name again, and
+            // a lazy one asked the server for the wrong order first.
+            const { key: sortKey, dir: sortDir } = this.sort();
+            const st = { widths, hidden, order, sortKey, sortDir };
             const key = JSON.stringify(st);
             untracked(() => {
                 if (key === this.lastStateKey)
@@ -14994,8 +15003,31 @@ class StrctDatagrid {
     }
     applyColumnState(st) {
         this.columnWidths.set(new Map(Object.entries(st.widths ?? {}).map(([k, v]) => [k, Number(v)])));
+        if (st.hidden)
+            this.hiddenDecidedByState = true;
         this.hiddenColumns.set(new Set(st.hidden ?? []));
         this.columnOrder.set(st.order?.length ? [...st.order] : null);
+        if (st.sortKey !== undefined)
+            this.sort.set({ key: st.sortKey, dir: st.sortDir ?? 'asc' });
+    }
+    /** Whether a persisted or bound state has already decided what is hidden. */
+    hiddenDecidedByState = false;
+    /** Whether the columns' own `hidden` flags have been read (once). */
+    declaredHiddenApplied = false;
+    /**
+     * Columns the consumer declared hidden — the default for a column no state
+     * mentions. A list that shows five of twenty columns says so on the columns,
+     * rather than seeding `columnState` and reaching into the library's storage
+     * key to keep from overriding what the operator chose.
+     */
+    applyDeclaredHidden(cols) {
+        if (this.declaredHiddenApplied || this.hiddenDecidedByState)
+            return;
+        this.declaredHiddenApplied = true;
+        const declared = cols.filter((c) => c.hidden).map((c) => c.key);
+        if (!declared.length)
+            return;
+        this.hiddenColumns.update((set) => new Set([...set, ...declared]));
     }
     /**
      * The grid as CSV: header labels + every non-hidden column, all rows in the
@@ -15003,17 +15035,32 @@ class StrctDatagrid {
      */
     toCSV() {
         const hidden = this.hiddenColumns();
-        const cols = this.columns().filter((c) => !hidden.has(c.key));
+        // The user's order, as the xlsx export already used: the same grid wrote
+        // its columns two different ways.
+        const cols = this.orderedColumns().filter((c) => !hidden.has(c.key));
         const esc = (v) => {
-            const s = v == null ? '' : String(v);
+            let s = v == null ? '' : String(v);
+            // A cell that opens with one of these is a formula to a spreadsheet, so
+            // a VM named "=HYPERLINK(…)" ran when the export was opened. A leading
+            // apostrophe is the spreadsheet's own "this is text".
+            if (/^[=+\-@\t\r]/.test(s))
+                s = `'${s}`;
             return /[",\n;]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s;
         };
         const data = this.lazy() ? this.rows() : this.sorted();
         return [
             cols.map((c) => esc(c.label)).join(','),
-            ...data.map((r) => cols.map((c) => esc(r[c.key])).join(',')),
+            ...data.map((r) => cols.map((c) => esc(this.exportValueOf(r, c))).join(',')),
         ].join('\n');
     }
+    /**
+     * What an export writes for a cell: what the column says, else the stored
+     * value. A templated cell shows "2 h 15 m" and stored 8100; without this the
+     * export carries the seconds, an enum code or a bare `true`.
+     */
+    exportValueOf(row, col) {
+        return col.exportValue ? col.exportValue(row) : row[col.key];
+    }
     /**
      * The grid as a real .xlsx workbook (dependency-free SpreadsheetML):
      * header labels + every non-hidden column in the current order, all rows in
@@ -15023,7 +15070,7 @@ class StrctDatagrid {
         const hidden = this.hiddenColumns();
         const cols = this.orderedColumns().filter((c) => !hidden.has(c.key));
         const data = this.lazy() ? this.rows() : this.sorted();
-        return buildXlsx(cols.map((c) => c.label), data.map((r) => cols.map((c) => r[c.key])));
+        return buildXlsx(cols.map((c) => c.label), data.map((r) => cols.map((c) => this.exportValueOf(r, c))));
     }
     /** Download the grid as an .xlsx file. */
     downloadXLSX(filename = 'datagrid.xlsx') {
@@ -15273,9 +15320,39 @@ class StrctDatagrid {
             .filter((r) => !!r);
         this.selectionChange.emit([...fresh, ...offData]);
     }
+    /**
+     * One row's sort key for a column: what the column says to sort by, else the
+     * stored value. A cell that shows "1.5 TB" sorts as text without this, which
+     * puts it before "900 GB"; a date written by toLocaleString sorts across
+     * days and AM/PM by its characters.
+     */
+    sortKeyOf(row, col, key) {
+        return col?.sortValue ? col.sortValue(row) : row[key];
+    }
+    /** The column a key belongs to — the comparator and the sort key need it. */
+    columnOf(key) {
+        return this.columns().find((c) => c.key === key);
+    }
+    /** Compare two rows by a column, honouring its comparator and nulls-last. */
+    compareRows(a, b, key, sign) {
+        const col = this.columnOf(key);
+        if (col?.comparator)
+            return sign * col.comparator(a, b);
+        const av = this.sortKeyOf(a, col, key);
+        const bv = this.sortKeyOf(b, col, key);
+        // An unread value is neither the smallest nor the largest: it is not an
+        // answer at all, so it goes last whichever way the column is sorted.
+        const aEmpty = av == null || av === '';
+        const bEmpty = bv == null || bv === '';
+        if (aEmpty || bEmpty)
+            return aEmpty && bEmpty ? 0 : aEmpty ? 1 : -1;
+        return sign * this.compare(av, bv);
+    }
     compare(a, b) {
         if (typeof a === 'number' && typeof b === 'number')
             return a - b;
+        if (a instanceof Date && b instanceof Date)
+            return a.getTime() - b.getTime();
         return String(a ?? '').localeCompare(String(b ?? ''), undefined, { numeric: true });
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: StrctDatagrid, deps: [], target: i0.ɵɵFactoryTarget.Component });