@web-utils/component 2.0.10 → 2.0.11

package/dist/chunks/3d28cc08.js

@@ -0,0 +1,57 @@
+function normalizeComponent(scriptExports, render, staticRenderFns, functionalTemplate, injectStyles, scopeId, moduleIdentifier, shadowMode) {
+  var options = typeof scriptExports === "function" ? scriptExports.options : scriptExports;
+  if (render) {
+    options.render = render;
+    options.staticRenderFns = staticRenderFns;
+    options._compiled = true;
+  }
+  if (functionalTemplate) {
+    options.functional = true;
+  }
+  if (scopeId) {
+    options._scopeId = "data-v-" + scopeId;
+  }
+  var hook;
+  if (moduleIdentifier) {
+    hook = function(context) {
+      context = context || this.$vnode && this.$vnode.ssrContext || this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext;
+      if (!context && typeof __VUE_SSR_CONTEXT__ !== "undefined") {
+        context = __VUE_SSR_CONTEXT__;
+      }
+      if (injectStyles) {
+        injectStyles.call(this, context);
+      }
+      if (context && context._registeredComponents) {
+        context._registeredComponents.add(moduleIdentifier);
+      }
+    };
+    options._ssrRegister = hook;
+  } else if (injectStyles) {
+    hook = shadowMode ? function() {
+      injectStyles.call(
+        this,
+        (options.functional ? this.parent : this).$root.$options.shadowRoot
+      );
+    } : injectStyles;
+  }
+  if (hook) {
+    if (options.functional) {
+      options._injectStyles = hook;
+      var originalRender = options.render;
+      options.render = function renderWithStyleInjection(h, context) {
+        hook.call(context);
+        return originalRender(h, context);
+      };
+    } else {
+      var existing = options.beforeCreate;
+      options.beforeCreate = existing ? [].concat(existing, hook) : [hook];
+    }
+  }
+  return {
+    exports: scriptExports,
+    options
+  };
+}
+export {
+  normalizeComponent as n
+};

package/dist/chunks/{41a066be.js → 44b78389.js}

@@ -1,4 +1,4 @@
-const t = {
+const inputNumberMixin = {
   props: {
     suffixIcon: {
       type: String
@@ -12,15 +12,15 @@ const t = {
     },
     stepStrictly: {
       type: Boolean,
-      default: !1
+      default: false
     },
     max: {
       type: Number,
-      default: 1 / 0
+      default: Infinity
     },
     min: {
       type: Number,
-      default: -1 / 0
+      default: -Infinity
     },
     value: {
       type: [Number, String]
@@ -31,7 +31,7 @@ const t = {
     },
     controls: {
       type: Boolean,
-      default: !0
+      default: true
     },
     controlsPosition: {
       type: String,
@@ -49,12 +49,12 @@ const t = {
     precision: {
       type: Number,
       default: void 0,
-      validator(e) {
-        return e >= 0 && e === parseInt(e, 10);
+      validator(val) {
+        return val >= 0 && val === parseInt(val, 10);
       }
     }
   }
 };
 export {
-  t as i
+  inputNumberMixin as i
 };

package/dist/chunks/5d33812d.js

@@ -0,0 +1,147 @@
+import { i as filterProperties } from "./c69d5628.js";
+import { Col, FormItem } from "element-ui";
+const elColManualBindKeys = ["span"];
+const elColKeys = [...Object.keys(Col.props)];
+const elColAutoBindKeys = elColKeys.filter((key) => !elColManualBindKeys.includes(key));
+const elFormItemManualBindKeys = ["label", "prop", "rules", "labelWidth", "required"];
+const elFormItemKeys = [...Object.keys(FormItem.props)];
+const elFormItemAutoBindKeys = elFormItemKeys.filter((key) => !elFormItemManualBindKeys.includes(key));
+const formItemAutoBindKeys = [
+  "wrapCol",
+  "wrapFormItem",
+  "unwrap",
+  "prefixConfig",
+  "block",
+  "placeholder",
+  "prefixPick",
+  "half",
+  ...elColKeys,
+  ...elFormItemKeys
+];
+const formItemMixin = {
+  inject: {
+    elForm: {
+      default: {}
+    },
+    formItemGroup: {
+      default: {}
+    }
+  },
+  props: {
+    disabled: Boolean,
+    wrapCol: {
+      type: Boolean,
+      default: true
+    },
+    wrapFormItem: {
+      type: Boolean,
+      default: true
+    },
+    unwrap: Boolean,
+    half: Boolean,
+    prefixConfig: Boolean,
+    block: Boolean,
+    placeholder: {
+      type: [Boolean, String],
+      default: true
+    },
+    formItemClass: String,
+    prefixPick: Boolean,
+    label: String,
+    labelWidth: String,
+    prop: String,
+    required: Boolean,
+    rules: [Object, Array],
+    error: String,
+    validateStatus: String,
+    for: String,
+    inlineMessage: {
+      type: [String, Boolean],
+      default: ""
+    },
+    showMessage: {
+      type: Boolean,
+      default: true
+    },
+    size: String,
+    span: {
+      type: Number,
+      default: 12
+    },
+    tag: {
+      type: String,
+      default: "div"
+    },
+    offset: Number,
+    pull: Number,
+    push: Number,
+    xs: [Number, Object],
+    sm: [Number, Object],
+    md: [Number, Object],
+    lg: [Number, Object],
+    xl: [Number, Object]
+  },
+  computed: {
+    prefix() {
+      if (this.prefixConfig) {
+        return "请配置";
+      } else if (this.prefixPick) {
+        return "请选择";
+      } else {
+        return "请输入";
+      }
+    },
+    message() {
+      var _a;
+      return `${this.prefix}${((_a = this.label) == null ? void 0 : _a.replace("：", "")) || ""}`;
+    },
+    computeRules() {
+      const rules = [...this.rules || []];
+      if (this.required) {
+        const requireRule = rules.find((value) => value.required);
+        if (requireRule) {
+          if (!requireRule.ref) {
+            requireRule.message = rules.message || this.message;
+          } else {
+            requireRule.label = requireRule.label || this.label;
+          }
+        } else {
+          rules.unshift(this.getRequireRule());
+        }
+      }
+      return rules.concat(this.getRules());
+    },
+    computeSpan() {
+      return this.block ? 24 : this.span;
+    },
+    formItemProps() {
+      return filterProperties({ ...this.$props, ...this.$attrs }, formItemAutoBindKeys);
+    },
+    elFormItemProps() {
+      return filterProperties({ ...this.$props, ...this.$attrs }, elFormItemAutoBindKeys);
+    },
+    elColProps() {
+      return filterProperties({ ...this.$props, ...this.$attrs }, elColAutoBindKeys);
+    }
+  },
+  watch: {
+    computeRules() {
+      var _a, _b;
+      (_b = (_a = this.elForm) == null ? void 0 : _a.clearValidate) == null ? void 0 : _b.call(_a, this.prop);
+    }
+  },
+  methods: {
+    getRules() {
+      return [];
+    },
+    getRequireRule() {
+      return {
+        required: true,
+        message: this.message
+      };
+    }
+  }
+};
+export {
+  formItemMixin as f
+};

package/dist/chunks/{61ad06b2.js → 822300f3.js}

@@ -1,11 +1,11 @@
-const e = {
+const formPickMixin = {
   props: {
     prefixPick: {
       type: Boolean,
-      default: !0
+      default: true
     }
   }
 };
 export {
-  e as f
+  formPickMixin as f
 };

package/dist/chunks/9d848bf6.js

@@ -0,0 +1,99 @@
+const parentMixin = {
+  mounted() {
+    if (this.value >= 0) {
+      this.currentIndex = this.value;
+    }
+    this.updateIndex();
+  },
+  methods: {
+    updateIndex() {
+      if (!this.$children || !this.$children.length) {
+        return;
+      }
+      this.number = this.$children.length;
+      const children = this.$children;
+      for (let i = 0; i < children.length; i++) {
+        children[i].currentIndex = i;
+        if (children[i].currentSelected) {
+          this.index = i;
+        }
+      }
+    }
+  },
+  props: {
+    value: Number
+  },
+  watch: {
+    currentIndex(val, oldVal) {
+      oldVal > -1 && this.$children[oldVal] && (this.$children[oldVal].currentSelected = false);
+      val > -1 && this.$children[val] && (this.$children[val].currentSelected = true);
+      this.$emit("input", val);
+      this.$emit("on-index-change", val, oldVal);
+    },
+    index(val) {
+      this.currentIndex = val;
+    },
+    value(val) {
+      this.index = val;
+    }
+  },
+  data() {
+    return {
+      index: -1,
+      currentIndex: this.index,
+      number: this.$children.length
+    };
+  }
+};
+const childMixin = {
+  props: {
+    selected: {
+      type: Boolean,
+      default: false
+    }
+  },
+  mounted() {
+    this.$parent.updateIndex();
+  },
+  beforeDestroy() {
+    const $parent = this.$parent;
+    this.$nextTick(() => {
+      $parent.updateIndex();
+    });
+  },
+  methods: {
+    onItemClick(hasLink) {
+      if (this.$parent.preventDefault) {
+        this.$parent.$emit("on-before-index-change", this.currentIndex);
+        return;
+      }
+      if (typeof this.disabled === "undefined" || this.disabled === false) {
+        this.currentSelected = true;
+        this.$parent.currentIndex = this.currentIndex;
+        this.$nextTick(() => {
+          this.$emit("on-item-click", this.currentIndex);
+        });
+      }
+    }
+  },
+  watch: {
+    currentSelected(val) {
+      if (val) {
+        this.$parent.index = this.currentIndex;
+      }
+    },
+    selected(val) {
+      this.currentSelected = val;
+    }
+  },
+  data() {
+    return {
+      currentIndex: -1,
+      currentSelected: this.selected
+    };
+  }
+};
+export {
+  childMixin as c,
+  parentMixin as p
+};

package/dist/chunks/a0bb327b.js

@@ -0,0 +1,96 @@
+import { MessageBox, Loading } from "element-ui";
+import { isFunction } from "@web-utils/core";
+async function onClick(e, props, listeners) {
+  const { stop, prevent, message, loadable, loadingText, confirmable, confirmType, confirmText } = props;
+  if (stop) {
+    e.stopPropagation();
+  }
+  if (prevent) {
+    e.preventDefault();
+  }
+  const { before, click, cancel, after } = listeners;
+  if (isFunction(click)) {
+    try {
+      let pass = true;
+      if (isFunction(before)) {
+        pass = await before(e);
+      }
+      if (pass === false) {
+        return;
+      }
+      if (confirmable) {
+        await MessageBox.confirm(message || confirmText, { type: confirmType });
+      }
+      let loadingInstance;
+      if (loadable) {
+        loadingInstance = Loading.service({ background: "rgba(0,0,0,0.3)", text: loadingText });
+      }
+      try {
+        await click(e);
+      } catch (e2) {
+      }
+      if (loadable) {
+        loadingInstance.close();
+      }
+      if (isFunction(after)) {
+        await after(e);
+      }
+    } catch (e2) {
+      if (isFunction(cancel)) {
+        await cancel(e2);
+      }
+    }
+  }
+}
+const confirmableMixin = {
+  functional: true,
+  props: {
+    stop: {
+      type: Boolean,
+      default: true
+    },
+    prevent: {
+      type: Boolean,
+      default: true
+    },
+    text: {
+      type: String,
+      default: ""
+    },
+    message: {
+      type: String,
+      default: "你确定要删除该记录吗？"
+    },
+    confirmable: {
+      type: Boolean,
+      default: true
+    },
+    confirmText: {
+      type: String,
+      default: "你确定要删除该记录吗？"
+    },
+    confirmType: {
+      type: String,
+      default: "warning"
+    },
+    loadable: Boolean,
+    loadingText: {
+      type: String,
+      default: "正在处理中请稍候..."
+    },
+    tag: {
+      type: String,
+      default: "i"
+    }
+  },
+  render(createElement, { props, data, children, listeners }) {
+    return createElement(props.tag, {
+      ...data,
+      on: { click: (e) => onClick(e, props, listeners) },
+      props
+    }, children || props.text);
+  }
+};
+export {
+  confirmableMixin as c
+};

package/dist/chunks/a8891d2c.js

@@ -0,0 +1,30 @@
+function secondsToStr(temp) {
+  const years = Math.floor(temp / 31536e3);
+  if (years) {
+    return `${years} 年${numberEnding(years)}`;
+  }
+  const days = Math.floor((temp %= 31536e3) / 86400);
+  if (days) {
+    return `${days} 天${numberEnding(days)}`;
+  }
+  const hours = Math.floor((temp %= 86400) / 3600);
+  if (hours) {
+    return `${hours} 时${numberEnding(hours)}`;
+  }
+  const minutes = Math.floor((temp %= 3600) / 60);
+  if (minutes) {
+    return `${minutes} 分${numberEnding(minutes)}`;
+  }
+  const seconds = temp % 60;
+  return `${seconds} 秒${numberEnding(seconds)}`;
+  function numberEnding(number) {
+    return number > 1 ? "" : "";
+  }
+}
+function kebabCase(s) {
+  return s.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+}
+export {
+  kebabCase as k,
+  secondsToStr as s
+};