@dfsj/components 3.0.0

package/dist/components/Form/src/useForm.js

@@ -0,0 +1,290 @@
+import _asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
+import _regeneratorRuntime from '@babel/runtime/regenerator';
+import { ref, unref, nextTick } from 'vue';
+import { isEmptyVal, isObject } from '../../../utils/is.js';
+
+var useForm = function useForm() {
+  var formRef = ref();
+  var elFormRef = ref();
+  var register = function register(ref, elRef) {
+    formRef.value = ref;
+    elFormRef.value = elRef;
+  };
+  var getForm = /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      var form;
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return nextTick();
+          case 2:
+            form = unref(formRef);
+            if (!form) {
+              console.error('The form is not registered. Please use the register method to register');
+            }
+            return _context.abrupt("return", form);
+          case 5:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    return function getForm() {
+      return _ref.apply(this, arguments);
+    };
+  }();
+  var methods = {
+    setProps: function () {
+      var _setProps = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+        var props,
+          form,
+          _args2 = arguments;
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              props = _args2.length > 0 && _args2[0] !== undefined ? _args2[0] : {};
+              _context2.next = 3;
+              return getForm();
+            case 3:
+              form = _context2.sent;
+              form === null || form === void 0 || form.setProps(props);
+              if (props.model) {
+                form === null || form === void 0 || form.setValues(props.model);
+              }
+            case 6:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2);
+      }));
+      function setProps() {
+        return _setProps.apply(this, arguments);
+      }
+      return setProps;
+    }(),
+    setValues: function () {
+      var _setValues = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(data) {
+        var form;
+        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              _context3.next = 2;
+              return getForm();
+            case 2:
+              form = _context3.sent;
+              form === null || form === void 0 || form.setValues(data);
+            case 4:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3);
+      }));
+      function setValues(_x) {
+        return _setValues.apply(this, arguments);
+      }
+      return setValues;
+    }(),
+    setSchema: function () {
+      var _setSchema = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(schemaProps) {
+        var form;
+        return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              _context4.next = 2;
+              return getForm();
+            case 2:
+              form = _context4.sent;
+              form === null || form === void 0 || form.setSchema(schemaProps);
+            case 4:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4);
+      }));
+      function setSchema(_x2) {
+        return _setSchema.apply(this, arguments);
+      }
+      return setSchema;
+    }(),
+    addSchema: function () {
+      var _addSchema = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(formSchema, index) {
+        var form;
+        return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              _context5.next = 2;
+              return getForm();
+            case 2:
+              form = _context5.sent;
+              form === null || form === void 0 || form.addSchema(formSchema, index);
+            case 4:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5);
+      }));
+      function addSchema(_x3, _x4) {
+        return _addSchema.apply(this, arguments);
+      }
+      return addSchema;
+    }(),
+    delSchema: function () {
+      var _delSchema = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6(field) {
+        var form;
+        return _regeneratorRuntime.wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              _context6.next = 2;
+              return getForm();
+            case 2:
+              form = _context6.sent;
+              form === null || form === void 0 || form.delSchema(field);
+            case 4:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6);
+      }));
+      function delSchema(_x5) {
+        return _delSchema.apply(this, arguments);
+      }
+      return delSchema;
+    }(),
+    getFormData: function () {
+      var _getFormData = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee7() {
+        var filterEmptyVal,
+          form,
+          model,
+          _args7 = arguments;
+        return _regeneratorRuntime.wrap(function _callee7$(_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              filterEmptyVal = _args7.length > 0 && _args7[0] !== undefined ? _args7[0] : true;
+              _context7.next = 3;
+              return getForm();
+            case 3:
+              form = _context7.sent;
+              model = form === null || form === void 0 ? void 0 : form.formModel;
+              if (!filterEmptyVal) {
+                _context7.next = 9;
+                break;
+              }
+              return _context7.abrupt("return", Object.keys(model).reduce(function (prev, next) {
+                var value = model[next];
+                if (!isEmptyVal(value)) {
+                  if (isObject(value)) {
+                    if (Object.keys(value).length > 0) {
+                      prev[next] = value;
+                    }
+                  } else {
+                    prev[next] = value;
+                  }
+                }
+                return prev;
+              }, {}));
+            case 9:
+              return _context7.abrupt("return", model);
+            case 10:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7);
+      }));
+      function getFormData() {
+        return _getFormData.apply(this, arguments);
+      }
+      return getFormData;
+    }(),
+    getComponentExpose: function () {
+      var _getComponentExpose = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee8(field) {
+        var form;
+        return _regeneratorRuntime.wrap(function _callee8$(_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              _context8.next = 2;
+              return getForm();
+            case 2:
+              form = _context8.sent;
+              return _context8.abrupt("return", form === null || form === void 0 ? void 0 : form.getComponentExpose(field));
+            case 4:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee8);
+      }));
+      function getComponentExpose(_x6) {
+        return _getComponentExpose.apply(this, arguments);
+      }
+      return getComponentExpose;
+    }(),
+    getFormItemExpose: function () {
+      var _getFormItemExpose = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee9(field) {
+        var form;
+        return _regeneratorRuntime.wrap(function _callee9$(_context9) {
+          while (1) switch (_context9.prev = _context9.next) {
+            case 0:
+              _context9.next = 2;
+              return getForm();
+            case 2:
+              form = _context9.sent;
+              return _context9.abrupt("return", form === null || form === void 0 ? void 0 : form.getFormItemExpose(field));
+            case 4:
+            case "end":
+              return _context9.stop();
+          }
+        }, _callee9);
+      }));
+      function getFormItemExpose(_x7) {
+        return _getFormItemExpose.apply(this, arguments);
+      }
+      return getFormItemExpose;
+    }(),
+    getElFormExpose: function () {
+      var _getElFormExpose = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee10() {
+        return _regeneratorRuntime.wrap(function _callee10$(_context10) {
+          while (1) switch (_context10.prev = _context10.next) {
+            case 0:
+              _context10.next = 2;
+              return getForm();
+            case 2:
+              return _context10.abrupt("return", unref(elFormRef));
+            case 3:
+            case "end":
+              return _context10.stop();
+          }
+        }, _callee10);
+      }));
+      function getElFormExpose() {
+        return _getElFormExpose.apply(this, arguments);
+      }
+      return getElFormExpose;
+    }(),
+    getFormExpose: function () {
+      var _getFormExpose = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee11() {
+        return _regeneratorRuntime.wrap(function _callee11$(_context11) {
+          while (1) switch (_context11.prev = _context11.next) {
+            case 0:
+              _context11.next = 2;
+              return getForm();
+            case 2:
+              return _context11.abrupt("return", unref(formRef));
+            case 3:
+            case "end":
+              return _context11.stop();
+          }
+        }, _callee11);
+      }));
+      function getFormExpose() {
+        return _getFormExpose.apply(this, arguments);
+      }
+      return getFormExpose;
+    }()
+  };
+  return {
+    formRegister: register,
+    formMethods: methods
+  };
+};
+
+export { useForm };

package/dist/components/Highlight/index.d.ts

@@ -0,0 +1,2 @@
+import Highlight from './src/Highlight.vue';
+export { Highlight };

package/dist/components/Highlight/src/Highlight.vue.d.ts

@@ -0,0 +1,41 @@
+import { PropType } from 'vue';
+declare const _default: import("vue").DefineComponent<{
+    tag: import("vue-types").VueTypeValidableDef<string, import("vue-types/dist/types").ValidatorFunction<string>> & {
+        default: string;
+    } & {
+        default: string;
+    };
+    keys: {
+        type: PropType<string[]>;
+        default: () => any[];
+    };
+    color: import("vue-types").VueTypeValidableDef<string, import("vue-types/dist/types").ValidatorFunction<string>> & {
+        default: string;
+    } & {
+        default: string;
+    };
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    tag: import("vue-types").VueTypeValidableDef<string, import("vue-types/dist/types").ValidatorFunction<string>> & {
+        default: string;
+    } & {
+        default: string;
+    };
+    keys: {
+        type: PropType<string[]>;
+        default: () => any[];
+    };
+    color: import("vue-types").VueTypeValidableDef<string, import("vue-types/dist/types").ValidatorFunction<string>> & {
+        default: string;
+    } & {
+        default: string;
+    };
+}>> & {
+    onClick?: (...args: any[]) => any;
+}, {
+    keys: string[];
+    tag: string;
+    color: string;
+}, {}>;
+export default _default;

package/dist/components/Highlight/src/Highlight.vue.js

@@ -0,0 +1,5 @@
+import script from './Highlight.vue2.js';
+
+script.__file = "src/components/Highlight/src/Highlight.vue";
+
+export { script as default };

package/dist/components/Highlight/src/Highlight.vue2.js

@@ -0,0 +1,62 @@
+import { defineComponent, computed, h, unref } from 'vue';
+import propTypes from '../../../utils/propTypes.js';
+
+var script = defineComponent({
+  name: 'Highlight',
+  props: {
+    tag: propTypes.string.def('span'),
+    keys: {
+      type: Array,
+      "default": function _default() {
+        return [];
+      }
+    },
+    color: propTypes.string.def('var(--el-color-primary)')
+  },
+  emits: ['click'],
+  setup: function setup(props, _ref) {
+    var emit = _ref.emit,
+      slots = _ref.slots;
+    var keyNodes = computed(function () {
+      return props.keys.map(function (key) {
+        return h('span', {
+          onClick: function onClick() {
+            emit('click', key);
+          },
+          style: {
+            color: props.color,
+            cursor: 'pointer'
+          }
+        }, key);
+      });
+    });
+    var parseText = function parseText(text) {
+      props.keys.forEach(function (key, index) {
+        var regexp = new RegExp(key, 'g');
+        text = text.replace(regexp, "{{".concat(index, "}}"));
+      });
+      return text.split(/{{|}}/);
+    };
+    var renderText = function renderText() {
+      if (!(slots !== null && slots !== void 0 && slots["default"])) return null;
+      var node = slots === null || slots === void 0 ? void 0 : slots["default"]()[0].children;
+      if (!node) {
+        return slots === null || slots === void 0 ? void 0 : slots["default"]()[0];
+      }
+      var textArray = parseText(node);
+      var regexp = /^[0-9]*$/;
+      var nodes = textArray.map(function (t) {
+        if (regexp.test(t)) {
+          return unref(keyNodes)[t] || t;
+        }
+        return t;
+      });
+      return h(props.tag, nodes);
+    };
+    return function () {
+      return renderText();
+    };
+  }
+});
+
+export { script as default };

package/dist/components/Icon/index.d.ts

@@ -0,0 +1,3 @@
+import Icon from './src/Icon.vue';
+import SvgIcon from './src/SvgIcon.vue';
+export { Icon, SvgIcon, };

package/dist/components/Icon/src/Icon.vue.d.ts

@@ -0,0 +1,49 @@
+import type { PropType } from 'vue';
+declare const _default: import("vue").DefineComponent<{
+    icon: import("vue-types").VueTypeValidableDef<string, import("vue-types/dist/types").ValidatorFunction<string>> & {
+        default: string;
+    };
+    color: import("vue-types").VueTypeValidableDef<string, import("vue-types/dist/types").ValidatorFunction<string>> & {
+        default: string;
+    };
+    size: {
+        type: PropType<string | number>;
+        default: number;
+    };
+    spin: import("vue-types").VueTypeValidableDef<boolean, import("vue-types/dist/types").ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+    prefix: import("vue-types").VueTypeValidableDef<string, import("vue-types/dist/types").ValidatorFunction<string>> & {
+        default: string;
+    } & {
+        default: string;
+    };
+}, (_ctx: any, _cache: any) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    icon: import("vue-types").VueTypeValidableDef<string, import("vue-types/dist/types").ValidatorFunction<string>> & {
+        default: string;
+    };
+    color: import("vue-types").VueTypeValidableDef<string, import("vue-types/dist/types").ValidatorFunction<string>> & {
+        default: string;
+    };
+    size: {
+        type: PropType<string | number>;
+        default: number;
+    };
+    spin: import("vue-types").VueTypeValidableDef<boolean, import("vue-types/dist/types").ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+    prefix: import("vue-types").VueTypeValidableDef<string, import("vue-types/dist/types").ValidatorFunction<string>> & {
+        default: string;
+    } & {
+        default: string;
+    };
+}>>, {
+    icon: string;
+    color: string;
+    size: string | number;
+    spin: boolean;
+    prefix: string;
+}, {}>;
+export default _default;

package/dist/components/Icon/src/Icon.vue.js

@@ -0,0 +1,5 @@
+import script from './Icon.vue2.js';
+
+script.__file = "src/components/Icon/src/Icon.vue";
+
+export { script as default };

package/dist/components/Icon/src/Icon.vue2.js

@@ -0,0 +1,123 @@
+import _asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
+import _regeneratorRuntime from '@babel/runtime/regenerator';
+import { defineComponent, ref, computed, watch, onMounted, openBlock, createBlock, normalizeClass, createElementBlock, normalizeStyle, unref, nextTick } from 'vue';
+import './SvgIcon.vue.js';
+import Iconify from '@iconify/iconify';
+import { isString } from '../../../utils/is.js';
+import propTypes from '../../../utils/propTypes.js';
+import script$1 from './SvgIcon.vue2.js';
+
+var SVG_END_WITH_FLAG = '|svg';
+var script = defineComponent({
+  __name: 'Icon',
+  props: {
+    icon: propTypes.string,
+    color: propTypes.string,
+    size: {
+      type: [String, Number],
+      "default": 16
+    },
+    spin: propTypes.bool.def(false),
+    prefix: propTypes.string.def('')
+  },
+  setup: function setup(__props) {
+    var props = __props;
+    var elRef = ref(null);
+    var isSvgIcon = computed(function () {
+      var _props$icon;
+      return (_props$icon = props.icon) === null || _props$icon === void 0 ? void 0 : _props$icon.endsWith(SVG_END_WITH_FLAG);
+    });
+    var getSvgIcon = computed(function () {
+      return props.icon.replace(SVG_END_WITH_FLAG, '');
+    });
+    var getIconRef = computed(function () {
+      return "".concat(props.prefix ? props.prefix + ':' : '').concat(props.icon);
+    });
+    var update = /*#__PURE__*/function () {
+      var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+        var el, icon, svg, span;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              if (!unref(isSvgIcon)) {
+                _context.next = 2;
+                break;
+              }
+              return _context.abrupt("return");
+            case 2:
+              el = unref(elRef);
+              if (el) {
+                _context.next = 5;
+                break;
+              }
+              return _context.abrupt("return");
+            case 5:
+              _context.next = 7;
+              return nextTick();
+            case 7:
+              icon = unref(getIconRef);
+              if (icon) {
+                _context.next = 10;
+                break;
+              }
+              return _context.abrupt("return");
+            case 10:
+              svg = Iconify.renderSVG(icon, {});
+              if (svg) {
+                el.textContent = '';
+                el.appendChild(svg);
+              } else {
+                span = document.createElement('span');
+                span.className = 'iconify';
+                span.dataset.icon = icon;
+                el.textContent = '';
+                el.appendChild(span);
+              }
+            case 12:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee);
+      }));
+      return function update() {
+        return _ref.apply(this, arguments);
+      };
+    }();
+    var getWrapStyle = computed(function () {
+      var size = props.size,
+        color = props.color;
+      var fs = size;
+      if (isString(size)) {
+        fs = parseInt(size, 10);
+      }
+      return {
+        fontSize: "".concat(fs, "px"),
+        color: color,
+        display: 'inline-flex'
+      };
+    });
+    watch(function () {
+      return props.icon;
+    }, update, {
+      flush: 'post'
+    });
+    onMounted(update);
+    return function (_ctx, _cache) {
+      return isSvgIcon.value ? (openBlock(), createBlock(script$1, {
+        key: 0,
+        size: __props.size,
+        name: getSvgIcon.value,
+        "class": normalizeClass([_ctx.$attrs["class"], 'anticon']),
+        spin: __props.spin
+      }, null, 8, ["size", "name", "class", "spin"])) : (openBlock(), createElementBlock("span", {
+        key: 1,
+        ref_key: "elRef",
+        ref: elRef,
+        "class": normalizeClass([_ctx.$attrs["class"], 'app-iconify anticon', __props.spin && 'app-iconify-spin']),
+        style: normalizeStyle(getWrapStyle.value)
+      }, null, 6));
+    };
+  }
+});
+
+export { script as default };

package/dist/components/Icon/src/SvgIcon.vue.d.ts

@@ -0,0 +1,45 @@
+import type { CSSProperties } from 'vue';
+declare const _default: import("vue").DefineComponent<{
+    prefix: {
+        type: StringConstructor;
+        default: string;
+    };
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    size: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    spin: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    symbolId: import("vue").ComputedRef<string>;
+    prefixCls: string;
+    getStyle: import("vue").ComputedRef<CSSProperties>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    prefix: {
+        type: StringConstructor;
+        default: string;
+    };
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    size: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    spin: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>>, {
+    prefix: string;
+    size: string | number;
+    spin: boolean;
+}, {}>;
+export default _default;

package/dist/components/Icon/src/SvgIcon.vue.js

@@ -0,0 +1,7 @@
+import script from './SvgIcon.vue2.js';
+import { render } from './SvgIcon.vue3.js';
+
+script.render = render;
+script.__file = "src/components/Icon/src/SvgIcon.vue";
+
+export { script as default };

package/dist/components/Icon/src/SvgIcon.vue2.js

@@ -0,0 +1,45 @@
+import { defineComponent, computed } from 'vue';
+
+var script = defineComponent({
+  name: 'SvgIcon',
+  props: {
+    prefix: {
+      type: String,
+      "default": 'icon'
+    },
+    name: {
+      type: String,
+      required: true
+    },
+    size: {
+      type: [Number, String],
+      "default": 16
+    },
+    spin: {
+      type: Boolean,
+      "default": false
+    }
+  },
+  setup: function setup(props) {
+    var prefixCls = 'ec-component-svg-icon';
+    var symbolId = computed(function () {
+      return "#".concat(props.prefix, "-").concat(props.name);
+    });
+    var getStyle = computed(function () {
+      var size = props.size;
+      var s = "".concat(size);
+      s = "".concat(s.replace('px', ''), "px");
+      return {
+        width: s,
+        height: s
+      };
+    });
+    return {
+      symbolId: symbolId,
+      prefixCls: prefixCls,
+      getStyle: getStyle
+    };
+  }
+});
+
+export { script as default };