@nokecy/qc-ui 1.1.23 → 1.1.24

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.
Files changed (6) hide show
  1. package/dist/cjs/ag-grid-plus/utils.d.ts +2 -3
  2. package/dist/cjs/ag-grid-plus/utils.js +85 -71
  3. package/dist/esm/ag-grid-plus/utils.d.ts +2 -3
  4. package/dist/esm/ag-grid-plus/utils.js +86 -71
  5. package/dist/umd/qc-ui.min.js +1 -1
  6. package/package.json +2 -1
package/dist/cjs/ag-grid-plus/utils.d.ts CHANGED
@@ -1,9 +1,8 @@
1
1
  import { ValueFormatterParams } from 'ag-grid-community';
2
2
  import { AgGridColumnPropsClone } from './interface';
3
3
  /**
4
- * 将高级查询规则转换为后端 Filter 字符串
5
- * 注意: 目前为了保持兼容性，只能尽量将 OR 转换为后端支持的格式(如 A=1|A=2)，
6
- * 复杂的嵌套 OR 可能需要后端升级支持。当前策略是尽力转换。
4
+ * 将高级查询规则转换为后端 Gridify Filter 字符串
5
+ * 使用 gridify-client 库确保安全性和兼容性
7
6
  */
8
7
  export declare const convertRulesToFilterString: (ruleGroup: any, colDefs: any[]) => string;
9
8
  declare const convertFilterModel: (filterModel: any, colDefs: AgGridColumnPropsClone[]) => string;
package/dist/cjs/ag-grid-plus/utils.js CHANGED
@@ -7,6 +7,7 @@ Object.defineProperty(exports, "__esModule", {
7
7
  exports.toTree = exports.flattenTreeDeep = exports.flatten = exports.dateValueFormatter = exports.dateTimeValueFormatter = exports.convertSortModel = exports.convertRulesToFilterString = exports.convertFilterModel = void 0;
8
8
  var _cloneDeep2 = _interopRequireDefault(require("lodash/cloneDeep"));
9
9
  var _dayjs = _interopRequireDefault(require("dayjs"));
10
+ var _gridifyClient = require("gridify-client");
10
11
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
11
12
  function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
12
13
  function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
@@ -19,92 +20,105 @@ function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o =
19
20
  function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
20
21
  function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
21
22
  function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
23
+ // Gridify 值转义函数
22
24
  var esc = function esc(v) {
23
- return v.replace(/([(),|,\\]|\/i)/g, '\\$1');
25
+ return String(v).replace(/([(),|,\\]|\/i)/g, '\\$1');
24
26
  };
25
27
 
26
- // --- Query Builder Logic Helpers (P0) ---
27
-
28
28
  /**
29
- * 将高级查询规则转换为后端 Filter 字符串
30
- * 注意: 目前为了保持兼容性，只能尽量将 OR 转换为后端支持的格式(如 A=1|A=2)，
31
- * 复杂的嵌套 OR 可能需要后端升级支持。当前策略是尽力转换。
29
+ * 将高级查询规则转换为后端 Gridify Filter 字符串
30
+ * 使用 gridify-client 库确保安全性和兼容性
32
31
  */
33
32
  var convertRulesToFilterString = exports.convertRulesToFilterString = function convertRulesToFilterString(ruleGroup, colDefs) {
34
33
  if (!ruleGroup || !ruleGroup.children || ruleGroup.children.length === 0) {
35
34
  return "";
36
35
  }
37
- var processGroup = function processGroup(group) {
38
- var results = [];
39
- var isAnd = group.logic === 'AND';
40
- group.children.forEach(function (child) {
41
- if (child.logic) {
42
- // Nested Group
43
- var childFilters = processGroup(child);
44
- if (childFilters.length > 0) {
45
- // 简单的嵌套处理，如果顶层是 AND，子组也是 AND，则展开
46
- // 如果逻辑不一致，目前简单的 Filter String 可能无法完美表达 ((A=1) AND (B=2)) OR (C=3)
47
- // 现在的降级策略：如果是 OR 组，尝试用逗号分隔（但标准是 AND 用逗号）
48
- // TODO: 确认后端是否支持 SQL-like filter string。
49
- // 假设目前只处理最简单的：平铺的 AND
50
- results.push.apply(results, _toConsumableArray(childFilters)); // 暂时打平
36
+ var mapOperator = function mapOperator(op) {
37
+ switch (op) {
38
+ case '=':
39
+ return _gridifyClient.ConditionalOperator.Equal;
40
+ case '!=':
41
+ return _gridifyClient.ConditionalOperator.NotEqual;
42
+ case '>':
43
+ return _gridifyClient.ConditionalOperator.GreaterThan;
44
+ case '>=':
45
+ return _gridifyClient.ConditionalOperator.GreaterThanOrEqual;
46
+ case '<':
47
+ return _gridifyClient.ConditionalOperator.LessThan;
48
+ case '<=':
49
+ return _gridifyClient.ConditionalOperator.LessThanOrEqual;
50
+ case 'contains':
51
+ return _gridifyClient.ConditionalOperator.Contains;
52
+ case 'startsWith':
53
+ return _gridifyClient.ConditionalOperator.StartsWith;
54
+ case 'endsWith':
55
+ return _gridifyClient.ConditionalOperator.EndsWith;
56
+ default:
57
+ return _gridifyClient.ConditionalOperator.Equal;
58
+ }
59
+ };
60
+ var processItem = function processItem(builder, item, isFirst) {
61
+ if (item.logic) {
62
+ // 嵌套组
63
+ builder.startGroup();
64
+ processGroup(builder, item);
65
+ builder.endGroup();
66
+ } else {
67
+ // 单条规则
68
+ if (item.value === undefined || item.value === null || item.value === '') {
69
+ return;
70
+ }
71
+
72
+ // 处理特殊操作符
73
+ if (item.operator === 'isEmpty') {
74
+ builder.addCondition(item.field, _gridifyClient.ConditionalOperator.Equal, '');
75
+ } else if (item.operator === 'isNotEmpty') {
76
+ builder.addCondition(item.field, _gridifyClient.ConditionalOperator.NotEqual, '');
77
+ } else if (item.operator === 'between' && Array.isArray(item.value)) {
78
+ // between 操作符需要拆成两个条件
79
+ if (item.value[0] !== null && item.value[0] !== undefined) {
80
+ builder.addCondition(item.field, _gridifyClient.ConditionalOperator.GreaterThanOrEqual, item.value[0], undefined, true);
81
+ }
82
+ if (item.value[1] !== null && item.value[1] !== undefined) {
83
+ if (item.value[0] !== null && item.value[0] !== undefined) {
84
+ builder.and();
85
+ }
86
+ builder.addCondition(item.field, _gridifyClient.ConditionalOperator.LessThanOrEqual, item.value[1], undefined, true);
51
87
  }
52
88
  } else {
53
- // Rule
54
- var colDef = colDefs.find(function (c) {
55
- return c.field === child.field;
56
- });
57
- var filter = getRuleFilter(child, colDef);
58
- if (filter) {
59
- results.push(filter);
89
+ var gridifyOp = mapOperator(item.operator);
90
+ // escapeValue = true 确保特殊字符（如 / , | ( ) \）被正确转义
91
+ builder.addCondition(item.field, gridifyOp, item.value, undefined, true);
92
+ }
93
+ }
94
+ };
95
+ var processGroup = function processGroup(builder, group) {
96
+ var validChildren = group.children.filter(function (child) {
97
+ if (child.logic) return true;
98
+ return child.value !== undefined && child.value !== null && child.value !== '';
99
+ });
100
+ validChildren.forEach(function (child, index) {
101
+ if (index > 0) {
102
+ // 根据组逻辑添加连接符
103
+ if (group.logic === 'OR') {
104
+ builder.or(true); // true = optional, 避免无效表达式
105
+ } else {
106
+ builder.and(true);
60
107
  }
61
108
  }
109
+ processItem(builder, child, index === 0);
62
110
  });
63
- return results;
64
111
  };
65
-
66
- // 目前为了兼容性，强制打平输出。高级功能的完整支持依赖后端。
67
- // 这里我们把所有规则都视为可以通过 convertFilterModel 处理的单元
68
- var filters = processGroup(ruleGroup);
69
- return filters.join(",");
70
- };
71
- var getRuleFilter = function getRuleFilter(rule, colDef) {
72
- var field = rule.field,
73
- operator = rule.operator,
74
- value = rule.value;
75
- if (value === undefined || value === null || value === "") return "";
76
- var objectKey = field;
77
-
78
- // 根据操作符构造查询串
79
- switch (operator) {
80
- case '=':
81
- return "".concat(objectKey, " = ").concat(value);
82
- case '!=':
83
- return "".concat(objectKey, " != ").concat(value);
84
- case '>':
85
- return "".concat(objectKey, " > ").concat(value);
86
- case '>=':
87
- return "".concat(objectKey, " >= ").concat(value);
88
- case '<':
89
- return "".concat(objectKey, " < ").concat(value);
90
- case '<=':
91
- return "".concat(objectKey, " <= ").concat(value);
92
- case 'contains':
93
- return "".concat(objectKey, " =* ").concat(esc(value));
94
- case 'startsWith':
95
- return "".concat(objectKey, " ^ ").concat(esc(value));
96
- case 'endsWith':
97
- // 后端可能不支持 endWith 语法，暂用 =*
98
- return "".concat(objectKey, " =* ").concat(esc(value));
99
- case 'between':
100
- if (Array.isArray(value)) {
101
- // 复用现有的 range 逻辑
102
- return getFilter(objectKey, value, colDef);
103
- }
104
- return "";
105
- default:
106
- // 默认回退到标准处理
107
- return getFilter(objectKey, value, colDef);
112
+ try {
113
+ var builder = new _gridifyClient.GridifyQueryBuilder({
114
+ allowEmptyGroups: true
115
+ });
116
+ processGroup(builder, ruleGroup);
117
+ var query = builder.build();
118
+ return query.filter || "";
119
+ } catch (e) {
120
+ console.error('Failed to build Gridify filter:', e);
121
+ return "";
108
122
  }
109
123
  };
110
124
  var getFilter = function getFilter(objectKey, value, colDef) {
package/dist/esm/ag-grid-plus/utils.d.ts CHANGED
@@ -1,9 +1,8 @@
1
1
  import { ValueFormatterParams } from 'ag-grid-community';
2
2
  import { AgGridColumnPropsClone } from './interface';
3
3
  /**
4
- * 将高级查询规则转换为后端 Filter 字符串
5
- * 注意: 目前为了保持兼容性，只能尽量将 OR 转换为后端支持的格式(如 A=1|A=2)，
6
- * 复杂的嵌套 OR 可能需要后端升级支持。当前策略是尽力转换。
4
+ * 将高级查询规则转换为后端 Gridify Filter 字符串
5
+ * 使用 gridify-client 库确保安全性和兼容性
7
6
  */
8
7
  export declare const convertRulesToFilterString: (ruleGroup: any, colDefs: any[]) => string;
9
8
  declare const convertFilterModel: (filterModel: any, colDefs: AgGridColumnPropsClone[]) => string;
package/dist/esm/ag-grid-plus/utils.js CHANGED
@@ -12,92 +12,107 @@ function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symb
12
12
  function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
13
13
  function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
14
14
  import dayjs from 'dayjs';
15
+ import { GridifyQueryBuilder, ConditionalOperator as GridifyOp } from 'gridify-client';
16
+
17
+ // Gridify 值转义函数
15
18
  var esc = function esc(v) {
16
- return v.replace(/([(),|,\\]|\/i)/g, '\\$1');
19
+ return String(v).replace(/([(),|,\\]|\/i)/g, '\\$1');
17
20
  };
18
21
 
19
- // --- Query Builder Logic Helpers (P0) ---
20
-
21
22
  /**
22
- * 将高级查询规则转换为后端 Filter 字符串
23
- * 注意: 目前为了保持兼容性，只能尽量将 OR 转换为后端支持的格式(如 A=1|A=2)，
24
- * 复杂的嵌套 OR 可能需要后端升级支持。当前策略是尽力转换。
23
+ * 将高级查询规则转换为后端 Gridify Filter 字符串
24
+ * 使用 gridify-client 库确保安全性和兼容性
25
25
  */
26
26
  export var convertRulesToFilterString = function convertRulesToFilterString(ruleGroup, colDefs) {
27
27
  if (!ruleGroup || !ruleGroup.children || ruleGroup.children.length === 0) {
28
28
  return "";
29
29
  }
30
- var processGroup = function processGroup(group) {
31
- var results = [];
32
- var isAnd = group.logic === 'AND';
33
- group.children.forEach(function (child) {
34
- if (child.logic) {
35
- // Nested Group
36
- var childFilters = processGroup(child);
37
- if (childFilters.length > 0) {
38
- // 简单的嵌套处理，如果顶层是 AND，子组也是 AND，则展开
39
- // 如果逻辑不一致，目前简单的 Filter String 可能无法完美表达 ((A=1) AND (B=2)) OR (C=3)
40
- // 现在的降级策略：如果是 OR 组，尝试用逗号分隔（但标准是 AND 用逗号）
41
- // TODO: 确认后端是否支持 SQL-like filter string。
42
- // 假设目前只处理最简单的：平铺的 AND
43
- results.push.apply(results, _toConsumableArray(childFilters)); // 暂时打平
30
+ var mapOperator = function mapOperator(op) {
31
+ switch (op) {
32
+ case '=':
33
+ return GridifyOp.Equal;
34
+ case '!=':
35
+ return GridifyOp.NotEqual;
36
+ case '>':
37
+ return GridifyOp.GreaterThan;
38
+ case '>=':
39
+ return GridifyOp.GreaterThanOrEqual;
40
+ case '<':
41
+ return GridifyOp.LessThan;
42
+ case '<=':
43
+ return GridifyOp.LessThanOrEqual;
44
+ case 'contains':
45
+ return GridifyOp.Contains;
46
+ case 'startsWith':
47
+ return GridifyOp.StartsWith;
48
+ case 'endsWith':
49
+ return GridifyOp.EndsWith;
50
+ default:
51
+ return GridifyOp.Equal;
52
+ }
53
+ };
54
+ var processItem = function processItem(builder, item, isFirst) {
55
+ if (item.logic) {
56
+ // 嵌套组
57
+ builder.startGroup();
58
+ processGroup(builder, item);
59
+ builder.endGroup();
60
+ } else {
61
+ // 单条规则
62
+ if (item.value === undefined || item.value === null || item.value === '') {
63
+ return;
64
+ }
65
+
66
+ // 处理特殊操作符
67
+ if (item.operator === 'isEmpty') {
68
+ builder.addCondition(item.field, GridifyOp.Equal, '');
69
+ } else if (item.operator === 'isNotEmpty') {
70
+ builder.addCondition(item.field, GridifyOp.NotEqual, '');
71
+ } else if (item.operator === 'between' && Array.isArray(item.value)) {
72
+ // between 操作符需要拆成两个条件
73
+ if (item.value[0] !== null && item.value[0] !== undefined) {
74
+ builder.addCondition(item.field, GridifyOp.GreaterThanOrEqual, item.value[0], undefined, true);
75
+ }
76
+ if (item.value[1] !== null && item.value[1] !== undefined) {
77
+ if (item.value[0] !== null && item.value[0] !== undefined) {
78
+ builder.and();
79
+ }
80
+ builder.addCondition(item.field, GridifyOp.LessThanOrEqual, item.value[1], undefined, true);
44
81
  }
45
82
  } else {
46
- // Rule
47
- var colDef = colDefs.find(function (c) {
48
- return c.field === child.field;
49
- });
50
- var filter = getRuleFilter(child, colDef);
51
- if (filter) {
52
- results.push(filter);
83
+ var gridifyOp = mapOperator(item.operator);
84
+ // escapeValue = true 确保特殊字符（如 / , | ( ) \）被正确转义
85
+ builder.addCondition(item.field, gridifyOp, item.value, undefined, true);
86
+ }
87
+ }
88
+ };
89
+ var processGroup = function processGroup(builder, group) {
90
+ var validChildren = group.children.filter(function (child) {
91
+ if (child.logic) return true;
92
+ return child.value !== undefined && child.value !== null && child.value !== '';
93
+ });
94
+ validChildren.forEach(function (child, index) {
95
+ if (index > 0) {
96
+ // 根据组逻辑添加连接符
97
+ if (group.logic === 'OR') {
98
+ builder.or(true); // true = optional, 避免无效表达式
99
+ } else {
100
+ builder.and(true);
53
101
  }
54
102
  }
103
+ processItem(builder, child, index === 0);
55
104
  });
56
- return results;
57
105
  };
58
-
59
- // 目前为了兼容性，强制打平输出。高级功能的完整支持依赖后端。
60
- // 这里我们把所有规则都视为可以通过 convertFilterModel 处理的单元
61
- var filters = processGroup(ruleGroup);
62
- return filters.join(",");
63
- };
64
- var getRuleFilter = function getRuleFilter(rule, colDef) {
65
- var field = rule.field,
66
- operator = rule.operator,
67
- value = rule.value;
68
- if (value === undefined || value === null || value === "") return "";
69
- var objectKey = field;
70
-
71
- // 根据操作符构造查询串
72
- switch (operator) {
73
- case '=':
74
- return "".concat(objectKey, " = ").concat(value);
75
- case '!=':
76
- return "".concat(objectKey, " != ").concat(value);
77
- case '>':
78
- return "".concat(objectKey, " > ").concat(value);
79
- case '>=':
80
- return "".concat(objectKey, " >= ").concat(value);
81
- case '<':
82
- return "".concat(objectKey, " < ").concat(value);
83
- case '<=':
84
- return "".concat(objectKey, " <= ").concat(value);
85
- case 'contains':
86
- return "".concat(objectKey, " =* ").concat(esc(value));
87
- case 'startsWith':
88
- return "".concat(objectKey, " ^ ").concat(esc(value));
89
- case 'endsWith':
90
- // 后端可能不支持 endWith 语法，暂用 =*
91
- return "".concat(objectKey, " =* ").concat(esc(value));
92
- case 'between':
93
- if (Array.isArray(value)) {
94
- // 复用现有的 range 逻辑
95
- return getFilter(objectKey, value, colDef);
96
- }
97
- return "";
98
- default:
99
- // 默认回退到标准处理
100
- return getFilter(objectKey, value, colDef);
106
+ try {
107
+ var builder = new GridifyQueryBuilder({
108
+ allowEmptyGroups: true
109
+ });
110
+ processGroup(builder, ruleGroup);
111
+ var query = builder.build();
112
+ return query.filter || "";
113
+ } catch (e) {
114
+ console.error('Failed to build Gridify filter:', e);
115
+ return "";
101
116
  }
102
117
  };
103
118
  var getFilter = function getFilter(objectKey, value, colDef) {