@logimaxx/kgrid 0.3.1 → 0.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/kgrid.js CHANGED
@@ -1,10 +1,73 @@
1
- /*! @logimaxx/kgrid | (c) Logimaxx System SRL — proprietary | https://logimaxx.ro | built 2026-08-27T12:47:37.279Z */
1
+ /*! @logimaxx/kgrid | (c) Logimaxx System SRL — proprietary | https://logimaxx.ro | built 2026-09-02T08:17:18.911Z */
2
2
 
3
3
  /* --- configure.js --- */
4
4
  /**
5
5
  * Host-app integration: call KGrid.configure({ ... }) before mounting tables.
6
6
  */
7
7
  (function (CT) {
8
+ /**
9
+ * Flag is on when the API/form value is true, 1, or "1".
10
+ * @param {*} v
11
+ * @returns {boolean}
12
+ */
13
+ CT.isFlagOn = function (v) {
14
+ return v === true || v === 1 || v === "1";
15
+ };
16
+
17
+ /**
18
+ * Walk form.elements (includes fields associated via form="id").
19
+ * Checkboxes always emit "1" or "0" — FormData omits unchecked boxes.
20
+ * @param {HTMLFormElement} form
21
+ * @returns {Record<string, *>}
22
+ */
23
+ function defaultSerializeForm(form) {
24
+ const out = {};
25
+ const els = form && form.elements;
26
+ if (!els) {
27
+ return out;
28
+ }
29
+ for (let i = 0; i < els.length; i++) {
30
+ const el = els[i];
31
+ const name = el.name;
32
+ if (!name || el.disabled) {
33
+ continue;
34
+ }
35
+ const type = el.type;
36
+ if (type === "submit" || type === "button" || type === "reset" || type === "file") {
37
+ continue;
38
+ }
39
+ if (type === "checkbox") {
40
+ out[name] = el.checked ? "1" : "0";
41
+ continue;
42
+ }
43
+ if (type === "radio") {
44
+ if (!el.checked) {
45
+ continue;
46
+ }
47
+ out[name] = el.value;
48
+ continue;
49
+ }
50
+ if (el.tagName === "SELECT" && el.multiple) {
51
+ out[name] = Array.from(el.selectedOptions).map(function (o) {
52
+ return o.value;
53
+ });
54
+ continue;
55
+ }
56
+ const value = el.value;
57
+ if (Object.prototype.hasOwnProperty.call(out, name)) {
58
+ if (!Array.isArray(out[name])) {
59
+ out[name] = [out[name]];
60
+ }
61
+ out[name].push(value);
62
+ } else {
63
+ out[name] = value;
64
+ }
65
+ }
66
+ return out;
67
+ }
68
+
69
+ CT.serializeFormDefault = defaultSerializeForm;
70
+
8
71
  const defaultConfig = {
9
72
  log: function () {},
10
73
  onError: function (err) {
@@ -19,21 +82,7 @@
19
82
  },
20
83
  /** @type {((context: object, onConfirm: Function, onCancel?: Function) => void)|null} */
21
84
  deleteConfirm: null,
22
- serializeForm: function (form, columns) {
23
- const fd = new FormData(form);
24
- const out = {};
25
- for (const [key, value] of fd.entries()) {
26
- if (Object.prototype.hasOwnProperty.call(out, key)) {
27
- if (!Array.isArray(out[key])) {
28
- out[key] = [out[key]];
29
- }
30
- out[key].push(value);
31
- } else {
32
- out[key] = value;
33
- }
34
- }
35
- return out;
36
- },
85
+ serializeForm: defaultSerializeForm,
37
86
  /** @type {Record<string, Function|object>|null} name → wrapper fn or field type plugin */
38
87
  customInputTypes: null,
39
88
  /** @deprecated use customInputTypes */
@@ -42,6 +91,8 @@
42
91
  kviews: null,
43
92
  /** Default delay (ms) before filter submit; 0 = immediate. Applies to the resolved filter-submit event. */
44
93
  filterDebounceMs: 300,
94
+ /** { get(key), set(key, value|null) } — null uses localStorage */
95
+ preferencesStorage: null,
45
96
  };
46
97
 
47
98
  CT._config = Object.assign({}, defaultConfig);
@@ -155,8 +206,15 @@
155
206
  "create": false,
156
207
  "update": false,
157
208
  "delete": false,
158
- "clone": false
209
+ "clone": false,
210
+ "columnChooser": false
159
211
  },
212
+ /** Persist key for layout (and filters). Required for localStorage. */
213
+ storageKey: null,
214
+ /** Extra suffix for saved filters only (e.g. company id). Layout ignores this. */
215
+ filterStorageScope: null,
216
+ columnChooserLabel: "Columns",
217
+ columnChooserResetLabel: "Reset columns",
160
218
  "defaultInteraction": "view",
161
219
  "insertFormRow": {
162
220
  "position": "top"
@@ -183,6 +241,10 @@
183
241
  label: null,
184
242
  name: null,
185
243
  hidden: false,
244
+ /** When true, column chooser cannot hide this column (still reorderable). */
245
+ locked: false,
246
+ /** Runtime: user hid this column via chooser. Not a schema flag. */
247
+ userHidden: false,
186
248
  /** CSS class(es) on header/filter/data/insert cells (alias: columnClass) */
187
249
  class: null,
188
250
  columnClass: null,
@@ -364,23 +426,58 @@
364
426
  return !!(f.delete || f.update || f.create || f.clone);
365
427
  };
366
428
 
429
+ /**
430
+ * Compact width for the row-actions column under table-layout:fixed
431
+ * (fixed layout ignores content; 1% caused overflow). Sized from max buttons
432
+ * shown in any mode (idle clone/delete vs editing save/cancel).
433
+ * @param {Object} [options]
434
+ * @returns {string} CSS width
435
+ */
436
+ CT.actionColumnWidth = function (options) {
437
+ const f = (options && options.features) || {};
438
+ const idle = (f.clone ? 1 : 0) + (f.delete ? 1 : 0);
439
+ const editing = f.update ? 2 : 0;
440
+ const insert = f.create ? 1 : 0;
441
+ const n = Math.max(idle, editing, insert, 1);
442
+ return (2.5 * n + 0.75).toFixed(2) + "rem";
443
+ };
444
+
367
445
  /**
368
446
  * Sync <colgroup> so row-actions width can collapse in view (table-layout: fixed).
369
447
  * @param {JQuery} $table
370
448
  * @param {number} dataColumnCount visible data columns (no row-actions)
371
449
  * @param {boolean} hasActions
450
+ * @param {Object} [options] table options (for action column width)
372
451
  */
373
- CT.syncActionColumnColgroup = function ($table, dataColumnCount, hasActions) {
452
+ CT.syncActionColumnColgroup = function ($table, dataColumnCount, hasActions, options, layoutColumns) {
374
453
  let $colgroup = $table.children("colgroup.kgrid-colgroup");
375
454
  if (!$colgroup.length) {
376
455
  $colgroup = $("<colgroup>").addClass("kgrid-colgroup").prependTo($table);
377
456
  }
378
457
  $colgroup.empty();
379
- for (let i = 0; i < dataColumnCount; i++) {
380
- $colgroup.append($("<col>"));
458
+ const named = Array.isArray(layoutColumns) ? layoutColumns : null;
459
+ if (named && named.length) {
460
+ named.forEach(function (col) {
461
+ const $col = $("<col>");
462
+ if (col && col.name) {
463
+ $col.attr("data-name", col.name);
464
+ }
465
+ if (col && col.userHidden) {
466
+ $col.addClass("kgrid-user-hidden");
467
+ }
468
+ $colgroup.append($col);
469
+ });
470
+ } else {
471
+ for (let i = 0; i < dataColumnCount; i++) {
472
+ $colgroup.append($("<col>"));
473
+ }
381
474
  }
382
475
  if (hasActions) {
383
- $colgroup.append($("<col>").addClass("kgrid-row-actions-col"));
476
+ $colgroup.append(
477
+ $("<col>")
478
+ .addClass("kgrid-row-actions-col")
479
+ .css("width", CT.actionColumnWidth(options))
480
+ );
384
481
  }
385
482
  };
386
483
 
@@ -439,6 +536,7 @@
439
536
  if (cls) {
440
537
  $el.addClass(cls);
441
538
  }
539
+ $el.toggleClass("kgrid-user-hidden", !!col.userHidden);
442
540
  return $el;
443
541
  };
444
542
  })(window.KGrid);
@@ -1106,8 +1204,9 @@
1106
1204
  * @param {HTMLFormElement|JQuery} filterFormEl
1107
1205
  * @param {Object} options
1108
1206
  * @param {Object} [collection] KViews collection
1207
+ * @param {{ skipInitSubmit?: boolean }} [extra]
1109
1208
  */
1110
- CT.setupDefaultFilters = function (filterFormEl, options, collection) {
1209
+ CT.setupDefaultFilters = function (filterFormEl, options, collection, extra) {
1111
1210
  const form = $(filterFormEl)[0];
1112
1211
  if (!form || !options || !options.features || !options.features.filtering) {
1113
1212
  return;
@@ -1168,7 +1267,7 @@
1168
1267
  const missing = persisted.some(function (col) {
1169
1268
  return urlFilter.indexOf(col.name + "=") === -1;
1170
1269
  });
1171
- if (missing) {
1270
+ if (missing && !(extra && extra.skipInitSubmit)) {
1172
1271
  collection.filtering.handleSubmit(form);
1173
1272
  }
1174
1273
  };
@@ -1323,6 +1422,40 @@
1323
1422
  return filterForm;
1324
1423
  };
1325
1424
 
1425
+ /** Write current form fields into collection.url.parameters.filter (same rules as KViews Filtering). */
1426
+ CT.syncFormFiltersToCollectionUrl = function (form, collection) {
1427
+ if (!form || !collection || !collection.url) {
1428
+ return;
1429
+ }
1430
+ if (!collection.url.parameters) {
1431
+ collection.url.parameters = {};
1432
+ }
1433
+ const filter = [];
1434
+ const els = form.elements;
1435
+ if (!els) {
1436
+ return;
1437
+ }
1438
+ for (let i = 0; i < els.length; i++) {
1439
+ const el = els[i];
1440
+ if (!el || !el.name) {
1441
+ continue;
1442
+ }
1443
+ const $el = $(el);
1444
+ const value = $el.val();
1445
+ if (value == null || value === "") {
1446
+ continue;
1447
+ }
1448
+ const operator = $el.attr("data-operator") || $el.data("operator") || "=";
1449
+ filter.push(el.name + operator + value);
1450
+ }
1451
+ collection.offset = 0;
1452
+ if (filter.length) {
1453
+ collection.url.parameters.filter = filter.join(",");
1454
+ } else {
1455
+ delete collection.url.parameters.filter;
1456
+ }
1457
+ };
1458
+
1326
1459
  CT.FilterForm = function (form) {
1327
1460
  this.form = $(form)[0];
1328
1461
  this.filter = (name, value, operator = "~=~") => {
@@ -1358,6 +1491,19 @@
1358
1491
 
1359
1492
  /* --- cells.js --- */
1360
1493
  (function (CT) {
1494
+ /**
1495
+ * Bootstrap switch wrapper around a checkbox used as a boolean flag.
1496
+ * @param {JQuery} $input
1497
+ * @returns {JQuery} wrapper
1498
+ */
1499
+ CT.wrapFlagSwitch = function ($input) {
1500
+ $input
1501
+ .attr({ type: "checkbox", role: "switch", value: "1" })
1502
+ .removeClass("form-control form-input form-control-sm")
1503
+ .addClass("form-check-input");
1504
+ return $("<div class='form-check form-switch kgrid-flag-switch mb-0'>").append($input);
1505
+ };
1506
+
1361
1507
  /**
1362
1508
  * Setup data cell
1363
1509
  * @param {Object} col
@@ -1427,6 +1573,10 @@
1427
1573
  $("<div>").addClass("cell-input").append(tpl).appendTo($cell);
1428
1574
  return $cell;
1429
1575
  }
1576
+ case "checkbox":
1577
+ input = $("<input autocomplete='off' type='checkbox' class='form-check-input'/>");
1578
+ skipValueAttr = true;
1579
+ break;
1430
1580
  default:
1431
1581
  if(CT.isValidInputType(updateType)) {
1432
1582
  input = $(`<input autocomplete='off' type='${updateType}' class='form-input form-control form-control-sm'/>`);
@@ -1466,7 +1616,8 @@
1466
1616
  if(!updateConfig.disabled && !updateConfig.readonly)
1467
1617
  input.attr("onchange","$(this).parents('tr').addClass('editing')");
1468
1618
 
1469
- $("<div>").addClass("cell-input").append(input).appendTo($cell);
1619
+ const $control = updateType === "checkbox" ? CT.wrapFlagSwitch(input) : input;
1620
+ $("<div>").addClass("cell-input").append($control).appendTo($cell);
1470
1621
  return $cell;
1471
1622
  };
1472
1623
  })(window.KGrid);
@@ -1484,38 +1635,16 @@
1484
1635
  return td;
1485
1636
  };
1486
1637
 
1487
- CT.setupDataBody = function (dataBody, options, labelsRow, filterForm, pagingFooter, noDataTbody) {
1638
+ /**
1639
+ * Fill a data <tr> with cells + optional row-actions (KViews item template).
1640
+ * @param {JQuery} dataRow
1641
+ * @param {Object} options
1642
+ * @returns {JQuery} dataRow
1643
+ */
1644
+ CT.fillDataRow = function (dataRow, options) {
1488
1645
  const columns = [...options.columns];
1489
- const dataRow = $("<tr>").appendTo(dataBody);
1490
- if(options.dataRowAttrs && typeof options.dataRowAttrs!=="object") {
1491
- throw new Error("options.dataRowAttrs must be an object");
1492
- }
1493
- const dataRowAttrs = {...(options.dataRowAttrs ?? {})};
1494
- Object.keys(dataRowAttrs).forEach(attr => dataRow.attr(attr,dataRowAttrs[attr]));
1495
-
1496
- {
1497
- dataBody.data("emptyview",noDataTbody);
1498
-
1499
- if(options?.features?.sorting) {
1500
- dataBody.data("sort",labelsRow);
1501
- }
1502
- if(pagingFooter) {
1503
- dataBody.data("paging",pagingFooter.find(".pages"))
1504
- .data("pagesizeinp",pagingFooter.find(".pagesize"))
1505
- .data("totalrecscount",pagingFooter.find(".totalrecscount"));
1506
- }
1507
-
1508
- if(filterForm) {
1509
- dataBody.data("filter",filterForm);
1510
- }
1511
-
1512
- if(options.type) {
1513
- dataBody.data("type",options.type);
1514
- }
1515
- }
1516
-
1517
1646
  const dataRowFormId = "data_row_form_"+CT.uuid()+"_{{this.id}}";
1518
- const editForm = options.features.update
1647
+ const editForm = options.features && options.features.update
1519
1648
  ? $("<form class='edit-form table-row-form'>").attr("id", dataRowFormId)
1520
1649
  : null;
1521
1650
 
@@ -1565,7 +1694,39 @@
1565
1694
  if (editForm) {
1566
1695
  CT.anchorRowForm(editForm, dataRow);
1567
1696
  }
1697
+ return dataRow;
1698
+ };
1699
+
1700
+ CT.setupDataBody = function (dataBody, options, labelsRow, filterForm, pagingFooter, noDataTbody) {
1701
+ const dataRow = $("<tr>").appendTo(dataBody);
1702
+ if(options.dataRowAttrs && typeof options.dataRowAttrs!=="object") {
1703
+ throw new Error("options.dataRowAttrs must be an object");
1704
+ }
1705
+ const dataRowAttrs = {...(options.dataRowAttrs ?? {})};
1706
+ Object.keys(dataRowAttrs).forEach(attr => dataRow.attr(attr,dataRowAttrs[attr]));
1568
1707
 
1708
+ {
1709
+ dataBody.data("emptyview",noDataTbody);
1710
+
1711
+ if(options?.features?.sorting) {
1712
+ dataBody.data("sort",labelsRow);
1713
+ }
1714
+ if(pagingFooter) {
1715
+ dataBody.data("paging",pagingFooter.find(".pages"))
1716
+ .data("pagesizeinp",pagingFooter.find(".pagesize"))
1717
+ .data("totalrecscount",pagingFooter.find(".totalrecscount"));
1718
+ }
1719
+
1720
+ if(filterForm) {
1721
+ dataBody.data("filter",filterForm);
1722
+ }
1723
+
1724
+ if(options.type) {
1725
+ dataBody.data("type",options.type);
1726
+ }
1727
+ }
1728
+
1729
+ CT.fillDataRow(dataRow, options);
1569
1730
  return dataBody;
1570
1731
  };
1571
1732
 
@@ -1678,6 +1839,10 @@
1678
1839
  case "hidden":
1679
1840
  input = $(`<input type='hidden' class='form-input form-control form-control-sm'/>`);
1680
1841
  break;
1842
+ case "checkbox":
1843
+ input = $("<input autocomplete='off' type='checkbox' class='form-check-input'/>");
1844
+ input.attr("data-type", insertType);
1845
+ break;
1681
1846
  default:
1682
1847
  if(CT.isValidInputType(insertType)) {
1683
1848
  input = $(`<input autocomplete='off' type='${insertType}' class='form-input form-control form-control-sm'/>`);
@@ -1688,12 +1853,14 @@
1688
1853
  }
1689
1854
  }
1690
1855
 
1691
- if(insertConfig.default != null && insertConfig.default !== "" && !input.val()) {
1692
- const defVal = (typeof insertConfig.default === "object" && insertConfig.default.value != null)
1693
- ? insertConfig.default.value
1694
- : insertConfig.default;
1695
- if(String(defVal).trim()) {
1696
- input.val(defVal).trigger("change");
1856
+ const rawDefault = (typeof insertConfig.default === "object" && insertConfig.default && insertConfig.default.value != null)
1857
+ ? insertConfig.default.value
1858
+ : insertConfig.default;
1859
+ if (insertType === "checkbox") {
1860
+ input.prop("checked", CT.isFlagOn(rawDefault));
1861
+ } else if(insertConfig.default != null && insertConfig.default !== "" && !input.val()) {
1862
+ if(String(rawDefault).trim()) {
1863
+ input.val(rawDefault).trigger("change");
1697
1864
  }
1698
1865
  }
1699
1866
 
@@ -1716,7 +1883,8 @@
1716
1883
  }
1717
1884
 
1718
1885
  if(insertConfig.type!=="hidden") {
1719
- const $td = $("<td>").append(input).appendTo(newRecordRow).attr("data-label", col.label);
1886
+ const $control = insertType === "checkbox" ? CT.wrapFlagSwitch(input) : input;
1887
+ const $td = $("<td>").append($control).appendTo(newRecordRow).attr("data-label", col.label);
1720
1888
  CT.applyColumnCellMeta($td, col);
1721
1889
  }
1722
1890
  CT.mountField({
@@ -1823,6 +1991,14 @@
1823
1991
  $(input).val(typeof val === "boolean" ? String(val) : val);
1824
1992
  });
1825
1993
 
1994
+ view.el.find("input[type='checkbox']").each((index, input) => {
1995
+ const col = colMap.get(input.name);
1996
+ if (!col) {
1997
+ return;
1998
+ }
1999
+ input.checked = CT.isFlagOn(item.attributes[col.name]);
2000
+ });
2001
+
1826
2002
  view.el.find("form.edit-form").off("submit").on("submit",(event)=>{
1827
2003
  const form = event.target;
1828
2004
  event.preventDefault();
@@ -1868,6 +2044,571 @@
1868
2044
  })(window.KGrid);
1869
2045
 
1870
2046
 
2047
+ /* --- preferences.js --- */
2048
+ /**
2049
+ * User preferences: column layout (order + hide) and filter values.
2050
+ * Layout is keyed by storageKey; filters also use filterStorageScope (e.g. company).
2051
+ */
2052
+ (function (CT) {
2053
+ CT.PREFERENCES_VERSION = 1;
2054
+
2055
+ CT.localStoragePreferences = {
2056
+ get: function (key) {
2057
+ try {
2058
+ const root = typeof window !== "undefined" ? window : globalThis;
2059
+ const ls = root && root.localStorage;
2060
+ if (!ls) {
2061
+ return null;
2062
+ }
2063
+ const raw = ls.getItem(key);
2064
+ return raw ? JSON.parse(raw) : null;
2065
+ } catch (err) {
2066
+ return null;
2067
+ }
2068
+ },
2069
+ set: function (key, value) {
2070
+ try {
2071
+ const root = typeof window !== "undefined" ? window : globalThis;
2072
+ const ls = root && root.localStorage;
2073
+ if (!ls) {
2074
+ return;
2075
+ }
2076
+ if (value == null) {
2077
+ ls.removeItem(key);
2078
+ return;
2079
+ }
2080
+ ls.setItem(key, JSON.stringify(value));
2081
+ } catch (err) {
2082
+ /* quota / private mode */
2083
+ }
2084
+ },
2085
+ };
2086
+
2087
+ CT.preferencesStorageFor = function (options) {
2088
+ if (options && options.preferencesStorage) {
2089
+ return options.preferencesStorage;
2090
+ }
2091
+ if (CT._config && CT._config.preferencesStorage) {
2092
+ return CT._config.preferencesStorage;
2093
+ }
2094
+ return CT.localStoragePreferences;
2095
+ };
2096
+
2097
+ CT.layoutStorageKey = function (storageKey) {
2098
+ return "kgrid:" + storageKey + ":layout";
2099
+ };
2100
+
2101
+ CT.filtersStorageKey = function (storageKey, scope) {
2102
+ let key = "kgrid:" + storageKey + ":filters";
2103
+ if (scope != null && String(scope) !== "") {
2104
+ key += ":" + String(scope);
2105
+ }
2106
+ return key;
2107
+ };
2108
+
2109
+ CT.chooserColumns = function (columns) {
2110
+ return (columns || []).filter(function (col) {
2111
+ return col && col.name && !col.hidden;
2112
+ });
2113
+ };
2114
+
2115
+ CT.layoutFromColumns = function (columns) {
2116
+ return {
2117
+ v: CT.PREFERENCES_VERSION,
2118
+ columns: CT.chooserColumns(columns).map(function (col) {
2119
+ return { name: col.name, hidden: !!col.userHidden };
2120
+ }),
2121
+ };
2122
+ };
2123
+
2124
+ CT.parseFilterExpression = function (part) {
2125
+ const s = String(part || "");
2126
+ const ops = ["~=~", ">=", "<=", "!=", "=", ">", "<"];
2127
+ for (let i = 0; i < ops.length; i++) {
2128
+ const op = ops[i];
2129
+ const idx = s.indexOf(op);
2130
+ if (idx > 0) {
2131
+ return {
2132
+ name: s.slice(0, idx),
2133
+ operator: op,
2134
+ value: s.slice(idx + op.length),
2135
+ };
2136
+ }
2137
+ }
2138
+ return null;
2139
+ };
2140
+
2141
+ CT.isUserFilterColumn = function (col) {
2142
+ return !!(
2143
+ col &&
2144
+ col.name &&
2145
+ !col.hidden &&
2146
+ (!col.features || col.features.filter !== false)
2147
+ );
2148
+ };
2149
+
2150
+ CT.readUserFilters = function (form, columns) {
2151
+ if (!form) {
2152
+ return [];
2153
+ }
2154
+ const out = [];
2155
+ (columns || []).forEach(function (col) {
2156
+ if (!CT.isUserFilterColumn(col)) {
2157
+ return;
2158
+ }
2159
+ const $field = CT.filterFormField(form, col.name);
2160
+ if (!$field.length) {
2161
+ return;
2162
+ }
2163
+ const value = $field.val();
2164
+ if (value == null || value === "" || (Array.isArray(value) && !value.length)) {
2165
+ return;
2166
+ }
2167
+ const operator =
2168
+ $field.attr("data-operator") ||
2169
+ (col.filter && col.filter.operator) ||
2170
+ "~=~";
2171
+ out.push({
2172
+ name: col.name,
2173
+ value: Array.isArray(value) ? value : String(value),
2174
+ operator: operator,
2175
+ });
2176
+ });
2177
+ return out;
2178
+ };
2179
+
2180
+ CT.applyUserFilters = function (form, columns, saved) {
2181
+ if (!form || !saved || !Array.isArray(saved.filters)) {
2182
+ return;
2183
+ }
2184
+ saved.filters.forEach(function (entry) {
2185
+ if (!entry || !entry.name) {
2186
+ return;
2187
+ }
2188
+ const col = (columns || []).find(function (c) {
2189
+ return c && c.name === entry.name;
2190
+ });
2191
+ if (!CT.isUserFilterColumn(col)) {
2192
+ return;
2193
+ }
2194
+ if (entry.value == null || entry.value === "") {
2195
+ return;
2196
+ }
2197
+ let $field = CT.filterFormField(form, entry.name);
2198
+ if (!$field.length) {
2199
+ CT.ensureFilterField(form, entry.name, entry.value, entry.operator);
2200
+ $field = CT.filterFormField(form, entry.name);
2201
+ }
2202
+ if (!$field.length) {
2203
+ return;
2204
+ }
2205
+ $field.val(entry.value);
2206
+ if (entry.operator) {
2207
+ $field.attr("data-operator", entry.operator);
2208
+ }
2209
+ });
2210
+ };
2211
+
2212
+ /** Copy URL filter parts onto the form when the field is missing or empty. */
2213
+ CT.ensureUrlFiltersOnForm = function (form, collection) {
2214
+ if (!form || !collection || !collection.url || !collection.url.parameters) {
2215
+ return;
2216
+ }
2217
+ const urlFilter = String(collection.url.parameters.filter || "");
2218
+ if (!urlFilter) {
2219
+ return;
2220
+ }
2221
+ urlFilter.split(",").forEach(function (part) {
2222
+ const parsed = CT.parseFilterExpression(part.trim());
2223
+ if (!parsed || !parsed.name || parsed.value === "") {
2224
+ return;
2225
+ }
2226
+ const $existing = CT.filterFormField(form, parsed.name);
2227
+ if ($existing.length && $existing.val()) {
2228
+ return;
2229
+ }
2230
+ if ($existing.length) {
2231
+ $existing.val(parsed.value);
2232
+ $existing.attr("data-operator", parsed.operator);
2233
+ return;
2234
+ }
2235
+ CT.ensureFilterField(form, parsed.name, parsed.value, parsed.operator);
2236
+ });
2237
+ };
2238
+
2239
+ CT.preferencesLoadLayout = function (options) {
2240
+ if (!options || !options.storageKey) {
2241
+ return null;
2242
+ }
2243
+ const stored = CT.preferencesStorageFor(options).get(
2244
+ CT.layoutStorageKey(options.storageKey)
2245
+ );
2246
+ if (!stored || stored.v !== CT.PREFERENCES_VERSION || !Array.isArray(stored.columns)) {
2247
+ return null;
2248
+ }
2249
+ return stored;
2250
+ };
2251
+
2252
+ CT.preferencesSaveLayout = function (options, layout) {
2253
+ if (!options || !options.storageKey) {
2254
+ return;
2255
+ }
2256
+ CT.preferencesStorageFor(options).set(
2257
+ CT.layoutStorageKey(options.storageKey),
2258
+ layout
2259
+ );
2260
+ };
2261
+
2262
+ CT.preferencesLoadFilters = function (options) {
2263
+ if (!options || !options.storageKey) {
2264
+ return null;
2265
+ }
2266
+ const stored = CT.preferencesStorageFor(options).get(
2267
+ CT.filtersStorageKey(options.storageKey, options.filterStorageScope)
2268
+ );
2269
+ if (!stored || stored.v !== CT.PREFERENCES_VERSION || !Array.isArray(stored.filters)) {
2270
+ return null;
2271
+ }
2272
+ return stored;
2273
+ };
2274
+
2275
+ CT.preferencesSaveFilters = function (options, filters) {
2276
+ if (!options || !options.storageKey) {
2277
+ return;
2278
+ }
2279
+ CT.preferencesStorageFor(options).set(
2280
+ CT.filtersStorageKey(options.storageKey, options.filterStorageScope),
2281
+ { v: CT.PREFERENCES_VERSION, filters: filters || [] }
2282
+ );
2283
+ };
2284
+
2285
+ CT.reorderColumns = function (columns, orderedVisibleNames) {
2286
+ const byName = new Map();
2287
+ const schemaHidden = [];
2288
+ (columns || []).forEach(function (col, i) {
2289
+ if (col && col.hidden) {
2290
+ schemaHidden.push({ col: col, index: i });
2291
+ return;
2292
+ }
2293
+ if (col && col.name) {
2294
+ byName.set(col.name, col);
2295
+ }
2296
+ });
2297
+ const visible = [];
2298
+ (orderedVisibleNames || []).forEach(function (name) {
2299
+ if (byName.has(name)) {
2300
+ visible.push(byName.get(name));
2301
+ byName.delete(name);
2302
+ }
2303
+ });
2304
+ byName.forEach(function (col) {
2305
+ visible.push(col);
2306
+ });
2307
+ const result = visible.slice();
2308
+ schemaHidden.forEach(function (entry) {
2309
+ result.splice(Math.min(entry.index, result.length), 0, entry.col);
2310
+ });
2311
+ return result;
2312
+ };
2313
+
2314
+ CT.mergeLayoutIntoColumns = function (columns, layout) {
2315
+ const list = (columns || []).slice();
2316
+ list.forEach(function (col) {
2317
+ if (col && !col.hidden) {
2318
+ col.userHidden = false;
2319
+ }
2320
+ });
2321
+ const visible = CT.chooserColumns(list);
2322
+ const byName = new Map(
2323
+ visible.map(function (col) {
2324
+ return [col.name, col];
2325
+ })
2326
+ );
2327
+ const orderedNames = [];
2328
+ const used = new Set();
2329
+ const saved = layout && Array.isArray(layout.columns) ? layout.columns : [];
2330
+ saved.forEach(function (entry) {
2331
+ if (!entry || !entry.name || !byName.has(entry.name)) {
2332
+ return;
2333
+ }
2334
+ const col = byName.get(entry.name);
2335
+ col.userHidden = !!entry.hidden && !col.locked;
2336
+ orderedNames.push(entry.name);
2337
+ used.add(entry.name);
2338
+ });
2339
+ visible.forEach(function (col) {
2340
+ if (!used.has(col.name)) {
2341
+ orderedNames.push(col.name);
2342
+ }
2343
+ });
2344
+ const merged = CT.reorderColumns(list, orderedNames);
2345
+ const chooser = CT.chooserColumns(merged);
2346
+ if (chooser.length && chooser.every(function (col) { return col.userHidden; })) {
2347
+ const unlock = chooser.find(function (col) { return !col.locked; }) || chooser[0];
2348
+ unlock.userHidden = false;
2349
+ }
2350
+ return merged;
2351
+ };
2352
+
2353
+ CT.applyLayoutToDom = function ($table, columns, options) {
2354
+ if (!$table || !$table.length) {
2355
+ return;
2356
+ }
2357
+ const order = CT.chooserColumns(columns).map(function (col) {
2358
+ return col.name;
2359
+ });
2360
+ const hidden = {};
2361
+ CT.chooserColumns(columns).forEach(function (col) {
2362
+ if (col.userHidden) {
2363
+ hidden[col.name] = true;
2364
+ }
2365
+ });
2366
+ const $rows = $table.find(
2367
+ ".thead-labels tr, .thead-filters tr, .before-main-tbody tr, .main-tbody tr, .after-main-tbody tr"
2368
+ );
2369
+ $rows.each(function () {
2370
+ const $row = $(this);
2371
+ const $action = $row.children(".kgrid-row-actions");
2372
+ const byName = {};
2373
+ $row.children("[data-name]").each(function () {
2374
+ byName[this.getAttribute("data-name")] = this;
2375
+ });
2376
+ order.forEach(function (name) {
2377
+ const el = byName[name];
2378
+ if (!el) {
2379
+ return;
2380
+ }
2381
+ if ($action.length) {
2382
+ $(el).insertBefore($action);
2383
+ } else {
2384
+ $row.append(el);
2385
+ }
2386
+ el.classList.toggle("kgrid-user-hidden", !!hidden[name]);
2387
+ });
2388
+ });
2389
+ const hasActions = $table.find(".kgrid-row-actions").length > 0;
2390
+ CT.syncActionColumnColgroup(
2391
+ $table,
2392
+ order.length,
2393
+ hasActions,
2394
+ options,
2395
+ CT.chooserColumns(columns)
2396
+ );
2397
+ };
2398
+
2399
+ CT.refreshCollectionTemplate = function (api, options) {
2400
+ if (!api || !api.instance || typeof CT.fillDataRow !== "function") {
2401
+ return;
2402
+ }
2403
+ const KViews = CT.getKViews(options && options.kviews);
2404
+ if (!KViews || typeof KViews.template !== "function") {
2405
+ return;
2406
+ }
2407
+ const $tr = $("<tr>");
2408
+ if (options.dataRowAttrs && CT.isPlainObject(options.dataRowAttrs)) {
2409
+ Object.keys(options.dataRowAttrs).forEach(function (attr) {
2410
+ $tr.attr(attr, options.dataRowAttrs[attr]);
2411
+ });
2412
+ }
2413
+ CT.fillDataRow($tr, options);
2414
+ const html = $("<div>").append($tr).html();
2415
+ const compiled = KViews.template(html);
2416
+ api.instance.template = compiled;
2417
+ (api.instance.items || []).forEach(function (item) {
2418
+ (item.views || []).forEach(function (view) {
2419
+ view.template = compiled;
2420
+ });
2421
+ });
2422
+ };
2423
+
2424
+ CT.setupFilterPersistence = function (form, options) {
2425
+ if (!form || !options || !options.storageKey) {
2426
+ return;
2427
+ }
2428
+ if (!options.features || !options.features.filtering) {
2429
+ return;
2430
+ }
2431
+ $(form)
2432
+ .off("submit.kgridFilterPrefs")
2433
+ .on("submit.kgridFilterPrefs", function () {
2434
+ CT.preferencesSaveFilters(options, CT.readUserFilters(form, options.columns));
2435
+ });
2436
+ };
2437
+
2438
+ CT.applyColumnLayout = function (api, options, layout) {
2439
+ options.columns = CT.mergeLayoutIntoColumns(options.columns, layout);
2440
+ const $table = api.$host.find("table").first();
2441
+ CT.applyLayoutToDom($table, options.columns, options);
2442
+ CT.refreshCollectionTemplate(api, options);
2443
+ if (typeof CT.renderColumnChooserPanel === "function") {
2444
+ const $panel = api.$host.find(".kgrid-column-chooser-panel");
2445
+ if ($panel.length) {
2446
+ CT.renderColumnChooserPanel($panel, options, api);
2447
+ }
2448
+ }
2449
+ return CT.layoutFromColumns(options.columns);
2450
+ };
2451
+ })(window.KGrid);
2452
+
2453
+
2454
+ /* --- column-chooser.js --- */
2455
+ /**
2456
+ * Column chooser: checkbox visibility + HTML5 drag reorder.
2457
+ */
2458
+ (function (CT) {
2459
+ function layoutFromPanel($panel) {
2460
+ const columns = [];
2461
+ $panel.find(".kgrid-column-chooser-list li[data-name]").each(function () {
2462
+ const name = this.getAttribute("data-name");
2463
+ const checked = $(this).find("input[type='checkbox']").prop("checked");
2464
+ columns.push({ name: name, hidden: !checked });
2465
+ });
2466
+ return { v: CT.PREFERENCES_VERSION, columns: columns };
2467
+ }
2468
+
2469
+ function visibleCount(layout) {
2470
+ return layout.columns.filter(function (c) {
2471
+ return !c.hidden;
2472
+ }).length;
2473
+ }
2474
+
2475
+ CT.renderColumnChooserPanel = function ($panel, options, api) {
2476
+ $panel.empty();
2477
+ const $list = $("<ul>").addClass("kgrid-column-chooser-list").appendTo($panel);
2478
+ CT.chooserColumns(options.columns).forEach(function (col) {
2479
+ const $li = $("<li>")
2480
+ .attr("draggable", "true")
2481
+ .attr("data-name", col.name)
2482
+ .appendTo($list);
2483
+ $("<span>")
2484
+ .addClass("kgrid-column-chooser-handle")
2485
+ .attr("aria-hidden", "true")
2486
+ .text("⋮⋮")
2487
+ .appendTo($li);
2488
+ const $label = $("<label>").appendTo($li);
2489
+ const $cb = $("<input>")
2490
+ .attr("type", "checkbox")
2491
+ .prop("checked", !col.userHidden)
2492
+ .appendTo($label);
2493
+ if (col.locked) {
2494
+ $cb.prop("disabled", true).attr("title", "This column cannot be hidden");
2495
+ }
2496
+ $label.append(document.createTextNode(" " + (col.label || col.name)));
2497
+ });
2498
+ $("<button>")
2499
+ .attr("type", "button")
2500
+ .addClass("btn btn-sm btn-outline-secondary kgrid-column-chooser-reset")
2501
+ .text(options.columnChooserResetLabel || "Reset columns")
2502
+ .appendTo($panel);
2503
+
2504
+ $panel
2505
+ .off("change.kgridChooser")
2506
+ .on("change.kgridChooser", "input[type='checkbox']", function () {
2507
+ const layout = layoutFromPanel($panel);
2508
+ if (visibleCount(layout) < 1) {
2509
+ this.checked = true;
2510
+ return;
2511
+ }
2512
+ api.setLayout(layout);
2513
+ });
2514
+
2515
+ $panel
2516
+ .off("click.kgridChooserReset")
2517
+ .on("click.kgridChooserReset", ".kgrid-column-chooser-reset", function () {
2518
+ api.resetLayout();
2519
+ });
2520
+
2521
+ let dragEl = null;
2522
+ $list.off(".kgridChooserDrag");
2523
+ $list.on("dragstart.kgridChooserDrag", "li", function (e) {
2524
+ dragEl = this;
2525
+ $(this).addClass("kgrid-column-chooser-dragging");
2526
+ if (e.originalEvent && e.originalEvent.dataTransfer) {
2527
+ e.originalEvent.dataTransfer.effectAllowed = "move";
2528
+ e.originalEvent.dataTransfer.setData("text/plain", this.getAttribute("data-name"));
2529
+ }
2530
+ });
2531
+ $list.on("dragend.kgridChooserDrag", "li", function () {
2532
+ $(this).removeClass("kgrid-column-chooser-dragging");
2533
+ dragEl = null;
2534
+ });
2535
+ $list.on("dragover.kgridChooserDrag", "li", function (e) {
2536
+ e.preventDefault();
2537
+ if (!dragEl || dragEl === this) {
2538
+ return;
2539
+ }
2540
+ const rect = this.getBoundingClientRect();
2541
+ const mid = rect.top + rect.height / 2;
2542
+ const clientY = e.originalEvent ? e.originalEvent.clientY : 0;
2543
+ if (clientY < mid) {
2544
+ this.parentNode.insertBefore(dragEl, this);
2545
+ } else {
2546
+ this.parentNode.insertBefore(dragEl, this.nextSibling);
2547
+ }
2548
+ });
2549
+ $list.on("drop.kgridChooserDrag", "li", function (e) {
2550
+ e.preventDefault();
2551
+ api.setLayout(layoutFromPanel($panel));
2552
+ });
2553
+ };
2554
+
2555
+ CT.setupColumnChooser = function ($host, options, api) {
2556
+ if (!options.features || !options.features.columnChooser) {
2557
+ return;
2558
+ }
2559
+ const $shell = CT.getTableInteractionHost($host);
2560
+ $shell.find(".kgrid-column-chooser").remove();
2561
+ const label = options.columnChooserLabel || "Columns";
2562
+ const $wrap = $("<div>").addClass("kgrid-column-chooser");
2563
+ const $btn = $("<button>")
2564
+ .attr("type", "button")
2565
+ .addClass("kgrid-column-chooser-toggle btn btn-sm btn-outline-secondary")
2566
+ .attr("title", label)
2567
+ .attr("aria-expanded", "false")
2568
+ .attr("aria-haspopup", "true")
2569
+ .html(
2570
+ '<i class="fas fa-table-columns" aria-hidden="true"></i>' +
2571
+ '<span class="kgrid-column-chooser-toggle-label"> ' +
2572
+ $("<div>").text(label).html() +
2573
+ "</span>"
2574
+ );
2575
+ const $panel = $("<div>")
2576
+ .addClass("kgrid-column-chooser-panel")
2577
+ .attr("hidden", "hidden");
2578
+ $wrap.append($btn, $panel);
2579
+ $shell.prepend($wrap);
2580
+ CT.renderColumnChooserPanel($panel, options, api);
2581
+
2582
+ function close() {
2583
+ $panel.attr("hidden", "hidden");
2584
+ $btn.attr("aria-expanded", "false");
2585
+ }
2586
+
2587
+ $btn.on("click", function (e) {
2588
+ e.stopPropagation();
2589
+ const open = !$panel.attr("hidden");
2590
+ if (open) {
2591
+ close();
2592
+ } else {
2593
+ $panel.removeAttr("hidden");
2594
+ $btn.attr("aria-expanded", "true");
2595
+ }
2596
+ });
2597
+
2598
+ const ns = "kgridChooser" + CT.uuid();
2599
+ $(document).on("pointerdown." + ns, function (e) {
2600
+ if (!document.body.contains($wrap[0])) {
2601
+ $(document).off("pointerdown." + ns);
2602
+ return;
2603
+ }
2604
+ if (!$wrap[0].contains(e.target)) {
2605
+ close();
2606
+ }
2607
+ });
2608
+ };
2609
+ })(window.KGrid);
2610
+
2611
+
1871
2612
  /* --- init.js --- */
1872
2613
  (function (CT) {
1873
2614
  /**
@@ -1928,9 +2669,40 @@
1928
2669
  }
1929
2670
  return api.setInteraction(api.getInteraction() === "edit" ? "view" : "edit");
1930
2671
  },
2672
+ getLayout() {
2673
+ return CT.layoutFromColumns(options.columns);
2674
+ },
2675
+ setLayout(layout) {
2676
+ CT.applyColumnLayout(api, options, layout);
2677
+ CT.preferencesSaveLayout(options, api.getLayout());
2678
+ return api.getLayout();
2679
+ },
2680
+ resetLayout() {
2681
+ const byName = new Map();
2682
+ options.columns.forEach(function (col) {
2683
+ if (col && col.name) {
2684
+ byName.set(col.name, col);
2685
+ }
2686
+ });
2687
+ options.columns = schemaOrder
2688
+ .map(function (name) {
2689
+ return byName.get(name);
2690
+ })
2691
+ .filter(Boolean);
2692
+ CT.preferencesSaveLayout(options, null);
2693
+ CT.applyColumnLayout(api, options, null);
2694
+ return api.getLayout();
2695
+ },
1931
2696
  };
1932
2697
 
1933
- options.columns = options.columns.map((col) => CT.normalizeColumnConfig(col));
2698
+ options.columns = (options.columns || []).map((col) => CT.normalizeColumnConfig(col));
2699
+ const schemaOrder = options.columns.map(function (col) {
2700
+ return col.name;
2701
+ });
2702
+ options.columns = CT.mergeLayoutIntoColumns(
2703
+ options.columns,
2704
+ CT.preferencesLoadLayout(options)
2705
+ );
1934
2706
 
1935
2707
  const handlers = options.handlers ?? {};
1936
2708
  delete options.handlers;
@@ -1998,7 +2770,13 @@
1998
2770
  const hasActionColumn = CT.hasActionColumn(options);
1999
2771
  const visibleColumnsCount = labelsRow.find("th").length;
2000
2772
  const dataColumnCount = visibleColumnsCount - (hasActionColumn ? 1 : 0);
2001
- CT.syncActionColumnColgroup(table, dataColumnCount, hasActionColumn);
2773
+ CT.syncActionColumnColgroup(
2774
+ table,
2775
+ dataColumnCount,
2776
+ hasActionColumn,
2777
+ options,
2778
+ CT.chooserColumns(options.columns)
2779
+ );
2002
2780
 
2003
2781
  const filterForm = options.filterForm ?? CT.setupFilterHeader(table, options);
2004
2782
 
@@ -2062,7 +2840,24 @@
2062
2840
  if (options.insertUrl) {
2063
2841
  api.instance.setUrl(options.insertUrl, "insert");
2064
2842
  }
2843
+ }
2844
+
2845
+ CT.setupDefaultFilters(filterForm, options, api.instance, { skipInitSubmit: true });
2846
+ const filterFormEl = filterForm && (filterForm.jquery ? filterForm[0] : filterForm);
2847
+ CT.applyUserFilters(
2848
+ filterFormEl,
2849
+ options.columns,
2850
+ CT.preferencesLoadFilters(options)
2851
+ );
2852
+ CT.ensureUrlFiltersOnForm(filterFormEl, api.instance);
2853
+ CT.setupFilterPersistence(filterFormEl, options);
2854
+ CT.setupColumnChooser($host, options, api);
2855
+
2856
+ if (options.url) {
2065
2857
  try {
2858
+ if (options.features && options.features.filtering && filterFormEl) {
2859
+ CT.syncFormFiltersToCollectionUrl(filterFormEl, api.instance);
2860
+ }
2066
2861
  await api.instance.loadFromRemote();
2067
2862
  } catch (error) {
2068
2863
  CT.onError(error);
@@ -2074,8 +2869,6 @@
2074
2869
  throw new Error("Invalid data: missing datasource url or data for table");
2075
2870
  }
2076
2871
 
2077
- CT.setupDefaultFilters(filterForm, options, api.instance);
2078
-
2079
2872
  return api;
2080
2873
  };
2081
2874
  })(window.KGrid);