eru-grid 0.0.54 → 0.0.55

package/fesm2022/eru-grid.mjs

@@ -194,9 +194,23 @@ const SELF_COLOURED_DATATYPES = new Set(['status', 'priority', 'tag', 'progress'
  */
 const ACTION_COLUMN_MIN_WIDTH = 56;
 const SEEDED_FIELD_KEYS = [
-    'dynamic_number', 'display_number_as', 'symbol_field', 'date_format', 'label',
+    'dynamic_number', 'display_number_as', 'symbol_field', 'date_format',
     'storage_name', 'folder_name', 'default_upload',
 ];
+/**
+ * Keys the model seeds only until the design panel overrides them EXPLICITLY,
+ * tracked by a companion flag rather than by "does the column hold a value".
+ *
+ * `label` is the case that forced this: it is in SEEDED_FIELD_KEYS' spirit —
+ * the model's label is the default and a grid may shorten it — but a column
+ * never arrives without one, so the seeded test ("column already has a value,
+ * leave it alone") was true from the first render and the model's label never
+ * reached a mapped column. A query-derived column kept showing its raw result
+ * key as the heading.
+ */
+const EXPLICITLY_OVERRIDDEN_FIELD_KEYS = {
+    label: 'label_overridden',
+};
 /**
  * Datatype aliases the data model emits that mean an existing DataTypes value.
  *
@@ -4077,33 +4091,34 @@ class EruGridStore {
         }
         return this.rows();
     }, ...(ngDevMode ? [{ debugName: "displayData" }] : []));
+    // The frozen grand total is the row the transform appended (or prepended) to
+    // the pivot data, so it is only there when the transform actually produced
+    // one. It skips totalling an empty result, so `data` can be [] with the
+    // grand-total config still on; indexing it then yields undefined and the
+    // frozen-row template renders a row that has no `_rowKey`. Read the row
+    // positionally but keep it only when it really is the grand total.
+    frozenGrandTotalRow = computed(() => {
+        if (!this.isPivotMode() || !this.pivotResult())
+            return null;
+        const config = this.configuration().config;
+        if (!config?.enableGrandTotal || !config?.freezeGrandTotal)
+            return null;
+        const data = this.pivotResult().data;
+        const row = config?.grandTotalPosition === 'before' ? data[0] : data[data.length - 1];
+        return row?._isGrandTotal ? row : null;
+    }, ...(ngDevMode ? [{ debugName: "frozenGrandTotalRow" }] : []));
     // Type-safe accessors for specific modes
     pivotGrandTotalData = computed(() => {
-        let pd = [];
-        if (this.isPivotMode() && this.pivotResult()) {
-            if (this.configuration().config?.enableGrandTotal) {
-                if (this.configuration().config?.freezeGrandTotal) {
-                    if (this.configuration().config?.grandTotalPosition === 'before') {
-                        pd = [this.pivotResult().data[0]];
-                    }
-                    else {
-                        pd = [this.pivotResult().data[this.pivotResult().data.length - 1]];
-                    }
-                }
-            }
-        }
-        return pd;
+        const row = this.frozenGrandTotalRow();
+        return row ? [row] : [];
     }, ...(ngDevMode ? [{ debugName: "pivotGrandTotalData" }] : []));
     // Type-safe accessors for specific modes
     pivotDisplayData = computed(() => {
         if (this.isPivotMode() && this.pivotResult()) {
-            if (this.configuration().config?.enableGrandTotal && this.configuration().config?.freezeGrandTotal) {
-                if (this.configuration().config?.grandTotalPosition === 'before') {
-                    return this.pivotResult().data.slice(1);
-                }
-                else {
-                    return this.pivotResult().data;
-                }
+            // Only drop the leading row when it is the frozen grand total that the
+            // header renders separately, never a real data row.
+            if (this.frozenGrandTotalRow() && this.configuration().config?.grandTotalPosition === 'before') {
+                return this.pivotResult().data.slice(1);
             }
             return this.pivotResult().data;
         }
@@ -4502,6 +4517,56 @@ class EruGridStore {
         const rows = this.rows().map(row => row.entity_id === rowId ? { ...row, ...updates } : row);
         this._rows.set(rows);
     }
+    /**
+     * Merge field values into the record with this id, wherever the grid is
+     * holding it — the flat row list AND the per-group buckets a board fills.
+     *
+     * For a consumer that edits a record somewhere else on the page and needs the
+     * grid to agree without refetching. `updateRow` is not enough on two counts:
+     * it only looks at `_rows`, so a grouped/board grid keeps the stale copy, and
+     * it replaces top-level row keys rather than merging into `entity_data`,
+     * where an entity-backed row keeps its fields.
+     *
+     * Unknown ids are ignored, so a caller can announce a change blindly.
+     */
+    patchRecord(entityId, fields) {
+        if (!entityId || !fields)
+            return;
+        const entries = Object.entries(fields);
+        if (entries.length === 0)
+            return;
+        const patch = (row) => {
+            if (!row || row.entity_id !== entityId)
+                return row;
+            const next = { ...row };
+            if (next.entity_data && typeof next.entity_data === 'object') {
+                next.entity_data = { ...next.entity_data, ...fields };
+            }
+            // An array-sourced row carries its fields at the top level instead. Only
+            // keys the row already has are touched, so this never invents columns.
+            for (const [key, value] of entries) {
+                if (key !== 'entity_data' && Object.prototype.hasOwnProperty.call(next, key)) {
+                    next[key] = value;
+                }
+            }
+            return next;
+        };
+        const holdsRecord = (rows) => rows.some(row => row?.entity_id === entityId);
+        if (holdsRecord(this._rows())) {
+            this._rows.set(this._rows().map(patch));
+        }
+        this._groupRows.update(current => {
+            let touched = false;
+            const next = new Map(current);
+            current.forEach((rows, groupId) => {
+                if (!holdsRecord(rows))
+                    return;
+                next.set(groupId, rows.map(patch));
+                touched = true;
+            });
+            return touched ? next : current;
+        });
+    }
     // Selection methods
     selectRow(rowId) {
         const selectedRowIds = new Set(this.selectedRowIds());
@@ -13756,9 +13821,13 @@ class ColumnDesignPanelComponent {
      * drift apart: a key that is inherited is always locked, and vice versa.
      *
      * SEEDED_FIELD_KEYS are the exception the resolver makes too: the model seeds
-     * them, this grid may then override them, so they stay editable here.
+     * them, this grid may then override them, so they stay editable here. So are
+     * EXPLICITLY_OVERRIDDEN_FIELD_KEYS, seeded the same way but tracked by a flag
+     * — `label` among them, which must stay typeable for the flag to ever be set.
      */
-    static INHERITED_KEYS = new Set(INHERITED_FIELD_KEYS.filter(k => !SEEDED_FIELD_KEYS.includes(k) && k !== 'datatype'));
+    static INHERITED_KEYS = new Set(INHERITED_FIELD_KEYS.filter(k => !SEEDED_FIELD_KEYS.includes(k) &&
+        !EXPLICITLY_OVERRIDDEN_FIELD_KEYS[k] &&
+        k !== 'datatype'));
     isInherited(key) {
         return this.isEntityMapped() && ColumnDesignPanelComponent.INHERITED_KEYS.has(key);
     }
@@ -14045,6 +14114,20 @@ class ColumnDesignPanelComponent {
         this.gridStore.updateColumnMeta(name, { [key]: value });
     }
     onText(key, value) {
+        // A typed heading is the author's, and stops the mapped field's label from
+        // seeding it on the next resolve; clearing the box hands the column back to
+        // the data model rather than pinning it to an empty header.
+        const flag = EXPLICITLY_OVERRIDDEN_FIELD_KEYS[key];
+        if (flag) {
+            const name = this.gridStore.selectedDesignColumn();
+            if (!name)
+                return;
+            const typed = String(value ?? '').trim();
+            this.gridStore.updateColumnMeta(name, typed
+                ? { [key]: value, [flag]: true }
+                : { [key]: null, [flag]: null });
+            return;
+        }
         this.patch(key, value);
     }
     onNumber(key, value) {
@@ -15789,7 +15872,7 @@ class EruGridComponent {
         }
     }
     trackByPivotRowFn(index, pivotRow) {
-        return pivotRow._rowKey || `pivot-row-${index}`;
+        return pivotRow?._rowKey || `pivot-row-${index}`;
     }
     trackByRowFn(index, row) {
         // Use both entity_id and index to ensure uniqueness even with duplicate entity_ids
@@ -16121,6 +16204,11 @@ class EruGridComponent {
      * including an explicit `false` on a checkbox — wins from then on. Without the
      * column in hand there is no way to tell "not set" from "set to the opposite",
      * so an override was overwritten on every resolve.
+     *
+     * EXPLICITLY_OVERRIDDEN_FIELD_KEYS work the same way but ask a companion flag
+     * instead, for keys a column always holds a value for — `label`, whose
+     * "already set" was true from the first render, so the model's label never
+     * won and a mapped column kept its raw result key as the heading.
      */
     buildMappedColumnPatch(meta, col) {
         const patch = {};
@@ -16132,6 +16220,9 @@ class EruGridComponent {
                 continue;
             if (seeded.has(k) && !isUnset(col?.[k]))
                 continue;
+            const overrideFlag = EXPLICITLY_OVERRIDDEN_FIELD_KEYS[k];
+            if (overrideFlag && col?.[overrideFlag])
+                continue;
             patch[k] = v;
         }
         // setColumns() stores the canonical datatype ('r_status' -> 'status'), so a
@@ -17033,5 +17124,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.2", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { ACTION_COLUMN_MIN_WIDTH, AttachmentComponent, CELL_RULE_OPERATORS, CheckboxComponent, ChipListComponent, ColumnConstraintsService, CompositeComponent, CurrencyComponent, CustomVirtualScrollStrategy, DATA_TYPES, DATETIME_FORMATS, DATE_FORMATS, DateComponent, DatetimeComponent, DurationComponent, EmailComponent, EruGridComponent, EruGridService, EruGridStore, GRID_COLOR_TOKENS, INHERITED_FIELD_KEYS, LocationComponent, MATERIAL_MODULES, MATERIAL_PROVIDERS, MONTH_SHORT_NAMES, NumberComponent, NumericInputDirective, PRESENTATION_DATATYPES, PRESET_CONFIG_DEFAULTS, PRESET_MANAGED_FIELDS, PeopleComponent, PhoneComponent, PriorityComponent, ProgressComponent, RatingComponent, SEEDED_FIELD_KEYS, SELF_COLOURED_DATATYPES, SelectComponent, StatusComponent, TagComponent, TextareaComponent, TextboxComponent, ThemeService, ThemeToggleComponent, WebsiteComponent, abbreviateNumber, abbreviationScaleFor, cellRuleBarPercent, cellRuleMatches, cellRuleToCss, cellStatAlias, cellTextStyleToCss, collectColumnStatRequests, columnCellRules, composeColorValue, effectiveValueDatatype, evaluateRowCondition, formatCellValue, formatDateTimeWithPattern, formatDateWithPattern, formatNumberValue, hasOwnCellRules, matchCellRule, matchColorRange, normalizeCellRender, normalizeDatatype, normalizeDateFormat, normalizeDateTimeFormat, parseCellDate, parseCellDateTime, parseColorValue, parseDateWithPattern, readRowValue, resolveColumnRules, resolveRowValue, resolveStatValue, rowSelectionKey, statusPillColors, tagPillColors, toDateOnlyString, toDateTimeString };
+export { ACTION_COLUMN_MIN_WIDTH, AttachmentComponent, CELL_RULE_OPERATORS, CheckboxComponent, ChipListComponent, ColumnConstraintsService, CompositeComponent, CurrencyComponent, CustomVirtualScrollStrategy, DATA_TYPES, DATETIME_FORMATS, DATE_FORMATS, DateComponent, DatetimeComponent, DurationComponent, EXPLICITLY_OVERRIDDEN_FIELD_KEYS, EmailComponent, EruGridComponent, EruGridService, EruGridStore, GRID_COLOR_TOKENS, INHERITED_FIELD_KEYS, LocationComponent, MATERIAL_MODULES, MATERIAL_PROVIDERS, MONTH_SHORT_NAMES, NumberComponent, NumericInputDirective, PRESENTATION_DATATYPES, PRESET_CONFIG_DEFAULTS, PRESET_MANAGED_FIELDS, PeopleComponent, PhoneComponent, PriorityComponent, ProgressComponent, RatingComponent, SEEDED_FIELD_KEYS, SELF_COLOURED_DATATYPES, SelectComponent, StatusComponent, TagComponent, TextareaComponent, TextboxComponent, ThemeService, ThemeToggleComponent, WebsiteComponent, abbreviateNumber, abbreviationScaleFor, cellRuleBarPercent, cellRuleMatches, cellRuleToCss, cellStatAlias, cellTextStyleToCss, collectColumnStatRequests, columnCellRules, composeColorValue, effectiveValueDatatype, evaluateRowCondition, formatCellValue, formatDateTimeWithPattern, formatDateWithPattern, formatNumberValue, hasOwnCellRules, matchCellRule, matchColorRange, normalizeCellRender, normalizeDatatype, normalizeDateFormat, normalizeDateTimeFormat, parseCellDate, parseCellDateTime, parseColorValue, parseDateWithPattern, readRowValue, resolveColumnRules, resolveRowValue, resolveStatValue, rowSelectionKey, statusPillColors, tagPillColors, toDateOnlyString, toDateTimeString };
 //# sourceMappingURL=eru-grid.mjs.map