@jetlinks-web/components 2.0.2-2 → 2.0.2-4

package/es/Search/Search.js

@@ -0,0 +1,249 @@
+/* Analyzed bindings: {
+  "columns": "props",
+  "type": "props",
+  "column": "props",
+  "style": "props",
+  "class": "props",
+  "labelWidth": "props",
+  "resetText": "props",
+  "submitText": "props",
+  "JColumnsProps": "setup-maybe-ref",
+  "SearchItemData": "setup-maybe-ref",
+  "SearchProps": "setup-maybe-ref",
+  "Terms": "setup-maybe-ref",
+  "Button": "setup-maybe-ref",
+  "Row": "setup-maybe-ref",
+  "Col": "setup-maybe-ref",
+  "Form": "setup-maybe-ref",
+  "FormItemRest": "setup-maybe-ref",
+  "set": "setup-maybe-ref",
+  "reactive": "setup-const",
+  "ref": "setup-const",
+  "provide": "setup-const",
+  "termsParamsFormat": "setup-maybe-ref",
+  "SearchItem": "setup-const",
+  "optionsMapKey": "setup-maybe-ref",
+  "props": "setup-reactive-const",
+  "columnOptionMap": "setup-ref",
+  "emit": "setup-const",
+  "terms": "setup-reactive-const",
+  "searchItems": "setup-ref",
+  "itemValueChange": "setup-const",
+  "handleItems": "setup-const",
+  "searchSubmit": "setup-const",
+  "resetNumber": "setup-ref",
+  "reset": "setup-const"
+} */
+import { defineComponent as _defineComponent } from 'vue';
+import { renderList as _renderList, Fragment as _Fragment, openBlock as _openBlock, createElementBlock as _createElementBlock, createVNode as _createVNode, unref as _unref, withCtx as _withCtx, createBlock as _createBlock, renderSlot as _renderSlot, toDisplayString as _toDisplayString, createTextVNode as _createTextVNode, normalizeStyle as _normalizeStyle, createElementVNode as _createElementVNode, normalizeClass as _normalizeClass, pushScopeId as _pushScopeId, popScopeId as _popScopeId } from "vue";
+const _withScopeId = n => (_pushScopeId("data-v-1712538746257"), n = n(), _popScopeId(), n);
+const _hoisted_1 = { class: "JSearch-content simple" };
+const _hoisted_2 = { class: "JSearch-items" };
+import { Button, Row, Col, Form, FormItemRest, } from 'ant-design-vue';
+import { set } from 'lodash-es';
+import { reactive, ref, provide } from 'vue';
+import { termsParamsFormat } from './util';
+import SearchItem from './Item.js';
+import { optionsMapKey } from './setting';
+const __sfc_main__ = _defineComponent({
+    props: {
+        columns: {
+            type: Array,
+            default: () => [],
+            required: true,
+        },
+        type: {
+            type: String,
+            default: 'terms',
+            required: true,
+        },
+        column: {
+            type: Number,
+            default: 4,
+        },
+        style: {
+            type: [String, Object],
+            default: undefined,
+        },
+        class: {
+            type: String,
+            default: '',
+        },
+        labelWidth: {
+            type: Number,
+            default: 40,
+        },
+        resetText: {
+            type: String,
+            default: '重置',
+        },
+        submitText: {
+            type: String,
+            default: '搜索',
+        },
+    },
+    emits: ["search"],
+    setup(__props, { emit: __emit }) {
+        const props = __props;
+        const columnOptionMap = ref(new Map());
+        const emit = __emit;
+        // 当前查询条件
+        const terms = reactive({ terms: [] });
+        const searchItems = ref([]); // 当前查询条件列表
+        provide(optionsMapKey, columnOptionMap);
+        const itemValueChange = (value, index) => {
+            set(terms.terms, [index], value);
+        };
+        const handleItems = (reset = false) => {
+            searchItems.value = [];
+            terms.terms = [];
+            columnOptionMap.value.clear();
+            let hasSearch = false;
+            props.columns.forEach((item, index) => {
+                if (item.search && Object.keys(item.search).length) {
+                    columnOptionMap.value.set(item.dataIndex, item.search);
+                    // 默认值
+                    const { search } = item;
+                    let defaultTerms = null;
+                    // 包含defaultValue 或者 defaultOnceValue
+                    if (search.defaultValue !== undefined ||
+                        search.defaultTermType ||
+                        search.defaultOnceValue) {
+                        const _value = search.defaultValue || reset
+                            ? search.defaultValue
+                            : search.defaultOnceValue;
+                        defaultTerms = {
+                            type: 'and',
+                            value: _value,
+                            termType: search.defaultTermType || 'like',
+                            column: item.dataIndex,
+                        };
+                    }
+                    if (search.defaultValue !== undefined ||
+                        search.defaultOnceValue !== undefined) {
+                        hasSearch = true;
+                    }
+                    terms.terms.push(defaultTerms);
+                    searchItems.value.push({
+                        ...item.search,
+                        sortIndex: item.search.first ? 0 : index + 1,
+                        title: item.title,
+                        column: item.dataIndex,
+                    });
+                }
+            });
+            if (hasSearch) {
+                searchSubmit();
+            }
+        };
+        /**
+         * 提交
+         */
+        const searchSubmit = () => {
+            emit('search', termsParamsFormat(terms.terms, columnOptionMap.value, 'low', props.type));
+        };
+        /**
+         * 重置查询
+         */
+        const resetNumber = ref(1);
+        const reset = () => {
+            resetNumber.value += 1;
+            handleItems(true);
+            if (props.type == 'object') {
+                emit('search', {});
+            }
+            else if (props.type == 'terms') {
+                emit('search', []);
+            }
+        };
+        handleItems();
+        return (_ctx, _cache) => {
+            return (_openBlock(), _createBlock(_unref(Form), {
+                model: terms,
+                onFinish: searchSubmit
+            }, {
+                default: _withCtx(() => [
+                    _createElementVNode("div", {
+                        class: _normalizeClass(['JSearch-warp', props.class]),
+                        style: _normalizeStyle(__props.style)
+                    }, [
+                        _createElementVNode("div", _hoisted_1, [
+                            _createElementVNode("div", _hoisted_2, [
+                                _createVNode(_unref(Row), { gutter: [16, 16] }, {
+                                    default: _withCtx(() => [
+                                        (_openBlock(true), _createElementBlock(_Fragment, null, _renderList(searchItems.value, (item, index) => {
+                                            return (_openBlock(), _createBlock(_unref(Col), {
+                                                key: index + '_' + item.column,
+                                                span: item.span || 24 / __props.column
+                                            }, {
+                                                default: _withCtx(() => [
+                                                    _createVNode(SearchItem, {
+                                                        "only-value": true,
+                                                        expand: false,
+                                                        index: index + 1,
+                                                        columns: searchItems.value,
+                                                        "component-props": item.componentProps,
+                                                        "terms-item": terms.terms[index],
+                                                        reset: resetNumber.value,
+                                                        "label-width": __props.labelWidth,
+                                                        onChange: (v) => itemValueChange(v, index)
+                                                    }, null, 8 /* PROPS */, ["index", "columns", "component-props", "terms-item", "reset", "label-width", "onChange"])
+                                                ]),
+                                                _: 2 /* DYNAMIC */
+                                            }, 1032 /* PROPS, DYNAMIC_SLOTS */, ["span"]));
+                                        }), 128 /* KEYED_FRAGMENT */)),
+                                        _createVNode(_unref(Col), {
+                                            span: 24 / __props.column
+                                        }, {
+                                            default: _withCtx(() => [
+                                                _renderSlot(_ctx.$slots, "footerRender", {
+                                                    reset: reset,
+                                                    submit: searchSubmit
+                                                }, () => [
+                                                    _createElementVNode("div", {
+                                                        class: "JSearch-footer--btns",
+                                                        style: _normalizeStyle({
+                                                            paddingLeft: `${__props.labelWidth + 8}px`,
+                                                        })
+                                                    }, [
+                                                        _createVNode(_unref(Button), {
+                                                            type: "stroke",
+                                                            onClick: reset
+                                                        }, {
+                                                            default: _withCtx(() => [
+                                                                _createTextVNode(_toDisplayString(__props.resetText), 1 /* TEXT */)
+                                                            ]),
+                                                            _: 1 /* STABLE */
+                                                        }),
+                                                        _createVNode(_unref(FormItemRest), null, {
+                                                            default: _withCtx(() => [
+                                                                _createVNode(_unref(Button), {
+                                                                    "html-type": "submit",
+                                                                    type: "primary"
+                                                                }, {
+                                                                    default: _withCtx(() => [
+                                                                        _createTextVNode(_toDisplayString(__props.submitText), 1 /* TEXT */)
+                                                                    ]),
+                                                                    _: 1 /* STABLE */
+                                                                })
+                                                            ]),
+                                                            _: 1 /* STABLE */
+                                                        })
+                                                    ], 4 /* STYLE */)
+                                                ])
+                                            ]),
+                                            _: 3 /* FORWARDED */
+                                        }, 8 /* PROPS */, ["span"])
+                                    ]),
+                                    _: 3 /* FORWARDED */
+                                })
+                            ])
+                        ])
+                    ], 6 /* CLASS, STYLE */)
+                ]),
+                _: 3 /* FORWARDED */
+            }, 8 /* PROPS */, ["model"]));
+        };
+    }
+});
+export default __sfc_main__;

package/es/Search/hooks/index.js

@@ -0,0 +1 @@
+export * from './useSearchItems';

package/es/Search/hooks/useSearchItems.js

@@ -0,0 +1,40 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { ref } from 'vue';
+import { sortBy } from 'lodash-es';
+var hasDefaultValue = function hasDefaultValue(item) {
+  return item.defaultValue !== undefined || item.defaultTermType || item.defaultOnceValue;
+};
+export var useSearchItems = function useSearchItems(columns, options) {
+  var items = ref([]);
+  var optionsMap = ref(new Map());
+  var handleColumns = function handleColumns() {
+    var _items = [];
+    var values = [];
+    columns.forEach(function (item, index) {
+      var search = item.search;
+      if (search && Object.keys(search).length) {
+        optionsMap.value.set(item.dataIndex, search);
+        if (hasDefaultValue(search)) {
+          var _value = search.defaultValue || search.defaultOnceValue;
+          values.push({
+            type: 'and',
+            value: _value,
+            termType: search.defaultTermType || 'like',
+            column: item.dataIndex
+          });
+        }
+        _items.push(_objectSpread(_objectSpread({}, item.search), {}, {
+          sortIndex: item.search.first ? 0 : index + 1,
+          column: item.dataIndex
+        }));
+      }
+    });
+    items.value = sortBy(_items, 'sortIndex');
+    options === null || options === void 0 ? void 0 : options.getDefaultValue(values);
+  };
+  handleColumns();
+  return {
+    searchItems: items,
+    searchOptionsMap: optionsMap
+  };
+};

package/es/Search/index.js

@@ -0,0 +1,4 @@
+import AdvancedSearch from './Advanced/index.js';
+import Search from './Search.js';
+export { AdvancedSearch };
+export default Search;

package/es/Search/setting.js

@@ -0,0 +1,91 @@
+import 'vue';
+import './typing';
+export var optionsMapKey = Symbol('searchOptionsMap');
+export var basicSearch = {
+  columns: {
+    type: Array,
+    default: function _default() {
+      return [];
+    },
+    required: true
+  },
+  type: {
+    type: String,
+    default: 'advanced'
+  }
+};
+export var typeOptions = [{
+  label: '或者',
+  value: 'or'
+}, {
+  label: '并且',
+  value: 'and'
+}];
+export var TermTypeMap = {
+  EQ: {
+    label: '=',
+    value: 'eq'
+  },
+  NOT: {
+    label: '!=',
+    value: 'not'
+  },
+  LIKE: {
+    label: '包含',
+    value: 'like'
+  },
+  NLIKE: {
+    label: '不包含',
+    value: 'nlike'
+  },
+  GT: {
+    label: '>',
+    value: 'gt'
+  },
+  GTE: {
+    label: '>=',
+    value: 'gte'
+  },
+  LT: {
+    label: '<',
+    value: 'lt'
+  },
+  LTE: {
+    label: '<=',
+    value: 'lte'
+  },
+  IN: {
+    label: '在...之中',
+    value: 'in'
+  },
+  NIN: {
+    label: '不在...之中',
+    value: 'nin'
+  },
+  BTW: {
+    label: '在...之间',
+    value: 'btw'
+  },
+  NBTW: {
+    label: '不在...之间',
+    value: 'nbtw'
+  }
+};
+export var termType = Object.values(TermTypeMap);
+export var componentType = {
+  input: 'input',
+  inputNumber: 'inputNumber',
+  password: 'password',
+  switch: 'switch',
+  radio: 'radio',
+  checkbox: 'checkbox',
+  time: 'time',
+  date: 'date',
+  timeRange: 'timeRange',
+  rangePicker: 'rangePicker',
+  treeSelect: 'treeSelect',
+  upload: 'upload',
+  tree: 'tree',
+  select: 'select',
+  component: 'component'
+};

package/es/Search/typing.js

@@ -0,0 +1 @@
+export {};

package/es/Search/util.js

@@ -0,0 +1,234 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { cloneDeep, isArray, isFunction, isString } from 'lodash-es';
+import { termType } from './setting';
+import './typing';
+/**
+ * 处理like，nlike特殊值
+ * @param v
+ */
+export var handleLikeValue = function handleLikeValue(v) {
+  if (isString(v)) {
+    return v.split('').reduce(function (pre, next) {
+      var _next = next;
+      if (next === '\\') {
+        _next = '\\\\';
+      } else if (next === '%') {
+        _next = '\\%';
+      }
+      return pre + _next;
+    }, '');
+  }
+  return v;
+};
+var handleItemValue = function handleItemValue(item, columnOptionMap) {
+  var _item = columnOptionMap.get(item.column);
+  if (!_item) return item;
+  if (_item.rename) {
+    item.column = _item.rename;
+  }
+  if (_item.handleValue && isFunction(_item.handleValue)) {
+    item.value = _item.handleValue(item.value, item);
+  }
+  if (['like', 'nlike'].includes(item.termType) && !!item.value) {
+    item.value = "%".concat(handleLikeValue(item.value), "%");
+  }
+  return item;
+};
+var isEmpty = function isEmpty(v) {
+  return v === undefined || v === null || v === '' || isArray(v) && v.length === 0;
+};
+var handleArrayToTerms = function handleArrayToTerms(terms, columnOptionMap) {
+  return terms.map(function (item) {
+    if (item.terms) {
+      var filterTerms = item.terms.filter(function (filterItem) {
+        return filterItem && !isEmpty(filterItem.value) && filterItem.termType !== undefined && filterItem.column !== undefined;
+      });
+      item.terms = filterTerms.map(function (result) {
+        return handleItemValue(result, columnOptionMap);
+      });
+    }
+    return item;
+  }).filter(function (item) {
+    var _item$terms;
+    return (_item$terms = item.terms) === null || _item$terms === void 0 ? void 0 : _item$terms.length;
+  });
+};
+/**
+ * 处理为外部使用
+ * @terms {Array} 表单数据
+ * @columnOptionMap {Map} column的Map对象
+ */
+export var termsParamsFormat = function termsParamsFormat(terms, columnOptionMap) {
+  var type = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'adv';
+  var searchType = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'terms';
+  // 过滤掉terms中value无效的item
+  var cloneParams = cloneDeep(terms);
+  if (searchType === 'terms') {
+    return type === 'adv' ? {
+      terms: handleArrayToTerms(cloneParams.terms, columnOptionMap)
+    } : cloneParams.filter(function (item) {
+      return item && !isEmpty(item.value) && item.column !== undefined;
+    }).map(function (item) {
+      return handleItemValue(item, columnOptionMap);
+    });
+  } else if (searchType == 'object') {
+    var result = {};
+    cloneParams.filter(function (item) {
+      return item && item.value !== undefined && item.value !== '';
+    }).forEach(function (item) {
+      _extends(result, _defineProperty({}, item.column, item.value));
+    });
+    return result;
+  }
+};
+/**
+ * TreeSelect过滤
+ * @param value 过滤值
+ * @param treeNode
+ * @param key
+ */
+export var filterTreeSelectNode = function filterTreeSelectNode(value, treeNode) {
+  var _treeNode$key;
+  var key = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'name';
+  return (_treeNode$key = treeNode[key]) === null || _treeNode$key === void 0 ? void 0 : _treeNode$key.includes(value);
+};
+/**
+ * Select过滤
+ * @param value 过滤值
+ * @param option
+ * @param key
+ */
+export var filterSelectNode = function filterSelectNode(value, option) {
+  var _option$key;
+  var key = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'label';
+  return (_option$key = option[key]) === null || _option$key === void 0 ? void 0 : _option$key.includes(value);
+};
+export var handleQData = function handleQData(terms) {
+  // 排序, null 往后放
+  terms.terms.forEach(function (a) {
+    for (var i = 0; i < a.terms.length; i++) {
+      for (var j = 0; j < a.terms.length - i - 1; j++) {
+        if (!a.terms[j] && a.terms[j + 1]) {
+          var temp = a.terms[j];
+          a.terms[j] = a.terms[j + 1];
+          a.terms[j + 1] = temp;
+        }
+      }
+    }
+  });
+  return terms;
+};
+export var hasExpand = function hasExpand(terms) {
+  var itemCount = 0;
+  terms.forEach(function (a) {
+    a.terms.forEach(function (b) {
+      if (b) {
+        itemCount += 1;
+      }
+    });
+  });
+  return itemCount >= 2;
+};
+export var compatibleOldTerms = function compatibleOldTerms(q) {
+  var _terms = [{
+    terms: [null, null, null]
+  }, {
+    terms: [null, null, null],
+    type: 'and'
+  }];
+  try {
+    var _terms$terms;
+    var terms = JSON.parse(q || '{}');
+    (_terms$terms = terms.terms) === null || _terms$terms === void 0 ? void 0 : _terms$terms.forEach(function (a, aIndex) {
+      var _a$terms;
+      a === null || a === void 0 ? void 0 : (_a$terms = a.terms) === null || _a$terms === void 0 ? void 0 : _a$terms.forEach(function (b, bIndex) {
+        _terms[aIndex].terms[bIndex] = b;
+      });
+      if (a.type) {
+        _terms[aIndex].type = a.type;
+      }
+    });
+    return {
+      terms: _terms
+    };
+  } catch (e) {
+    return {
+      terms: _terms
+    };
+  }
+};
+export var handleParamsToString = function handleParamsToString() {
+  var terms = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'and';
+  var _terms = [{
+    terms: [null, null, null]
+  }, {
+    terms: [null, null, null],
+    type: type
+  }];
+  var termsIndex = 0;
+  var termsStar = 0;
+  terms.forEach(function (item, index) {
+    if (index > 2) {
+      termsIndex = 1;
+      termsStar = 4;
+    }
+    _terms[termsIndex].terms[index - termsStar] = item;
+  });
+  return JSON.stringify({
+    terms: _terms
+  });
+};
+export var getTermTypeFn = function getTermTypeFn(type) {
+  // if (column?.includes('id') && type === 'string') {
+  //     // 默认id为 eq
+  //     return 'eq';
+  // }
+  switch (type) {
+    case 'select':
+    case 'treeSelect':
+    case 'number':
+      return 'eq';
+    case 'date':
+    case 'time':
+      return 'gt';
+    case 'timeRange':
+    case 'rangePicker':
+      return 'btw';
+    default:
+      return 'like';
+  }
+};
+export var getTermTypes = function getTermTypes(types) {
+  return termType.filter(function (item) {
+    return types.includes(item.value);
+  });
+};
+export var getTermOptions = function getTermOptions(type, column) {
+  var keys = [];
+  switch (type) {
+    case 'select':
+    case 'treeSelect':
+      keys = ['not', 'eq', 'in', 'nin'];
+      break;
+    case 'time':
+    case 'date':
+      keys = ['gt', 'lt', 'gte', 'lte'];
+      break;
+    case 'timeRange':
+    case 'rangePicker':
+      keys = ['btw', 'nbtw'];
+      break;
+    case 'number':
+      keys = ['eq', 'not', 'gt', 'lt', 'gte', 'lte'];
+      break;
+    default:
+      keys = ['like', 'nlike'];
+      // column?.includes('id') && type === 'string'
+      //     ? ['eq']
+      //     : ['like', 'nlike'];
+      break;
+  }
+  return keys.length ? getTermTypes(keys) : termType;
+};