@web-utils/component 2.0.12 → 2.0.14

package/package.json

@@ -1,8 +1,7 @@
 {
   "name": "@web-utils/component",
-  "version": "2.0.12",
+  "version": "2.0.14",
   "type": "module",
-  "sideEffects": ["*.css"],
   "private": false,
   "license": "MIT",
   "main": "./dist/index.es.js",

package/web-types.json

@@ -2,7 +2,7 @@
   "$schema": "https://json.schemastore.org/web-types",
   "framework": "vue",
   "name": "@web-utils/component",
-  "version": "2.0.12",
+  "version": "2.0.14",
   "contributions": {
     "html": {
       "description-markup": "markdown",

package/dist/chunks/3d28cc08.js

@@ -1,57 +0,0 @@
-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/5d33812d.js

@@ -1,147 +0,0 @@
-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/9d848bf6.js

@@ -1,99 +0,0 @@
-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

@@ -1,96 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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
-};

package/dist/chunks/c69d5628.js

@@ -1,248 +0,0 @@
-import { isObject, isString, hasOwn, isPlainObject, isArray, camelize, isFunction } from "@web-utils/core";
-import Vue from "vue";
-const util = "";
-const getClass = (customClass, fixedClass) => {
-  if (isPlainObject(customClass) || isString(customClass)) {
-    return [fixedClass, customClass];
-  } else if (isArray(customClass)) {
-    return [fixedClass, ...customClass];
-  } else {
-    return [fixedClass];
-  }
-};
-function getInternetExplorerVersion() {
-  const ua = window.navigator.userAgent;
-  const msie = ua.indexOf("MSIE ");
-  if (msie > 0) {
-    return parseInt(ua.substring(msie + 5, ua.indexOf(".", msie)), 10);
-  }
-  const trident = ua.indexOf("Trident/");
-  if (trident > 0) {
-    const rv = ua.indexOf("rv:");
-    return parseInt(ua.substring(rv + 3, ua.indexOf(".", rv)), 10);
-  }
-  const edge = ua.indexOf("Edge/");
-  if (edge > 0) {
-    return parseInt(ua.substring(edge + 5, ua.indexOf(".", edge)), 10);
-  }
-  return -1;
-}
-function assignReactiveProperties(raw, properties) {
-  for (const propertiesKey in properties) {
-    Vue.set(raw, propertiesKey, properties[propertiesKey]);
-  }
-  return raw;
-}
-const findParent = (vm, predicate) => {
-  if (!vm || !predicate) {
-    return null;
-  }
-  let parent = vm;
-  while (parent && predicate(parent)) {
-    parent = parent.$parent;
-  }
-  return parent;
-};
-const elTableProperties = [
-  "data",
-  "height",
-  "max-height",
-  "stripe",
-  "border",
-  "size",
-  "fit",
-  "show-header",
-  "highlight-current-row",
-  "current-row-key",
-  "row-class-name",
-  "row-style",
-  "cell-class-name",
-  "cell-style",
-  "header-row-class-name",
-  "header-row-style",
-  "header-cell-class-name",
-  "header-cell-style",
-  "row-key",
-  "empty-text",
-  "default-expand-all",
-  "expand-row-keys",
-  "default-sort",
-  "tooltip-effect",
-  "show-summary",
-  "sum-text",
-  "summary-method",
-  "span-method",
-  "select-on-indeterminate ",
-  "indent",
-  "lazy",
-  "load",
-  "tree-props"
-];
-const elTableEvents = [
-  "select",
-  "select-all",
-  "selection-change",
-  "cell-mouse-enter",
-  "cell-mouse-leave",
-  "cell-click",
-  "cell-dblclick",
-  "row-click",
-  "row-contextmenu",
-  "header-click",
-  "header-contextmenu",
-  "sort-change",
-  "filter-change",
-  "current-change",
-  "header-dragend",
-  "expand-change"
-];
-const elTableColumnProperties = [
-  "type",
-  "index",
-  "column-key",
-  "label",
-  "prop",
-  "width",
-  "min-width",
-  "fixed",
-  "render-header",
-  "sortable",
-  "sort-method",
-  "sort-by",
-  "sort-orders",
-  "resizable",
-  "formatter",
-  "show-overflow-tooltip",
-  "align",
-  "header-align",
-  "class-name",
-  "label-class-name",
-  "selectable",
-  "reserve-selection",
-  "filters",
-  "filter-placement",
-  "filter-multiple",
-  "filter-method",
-  "filtered-value"
-];
-const elTreeProperties = [
-  "data",
-  "empty-text",
-  "node-key",
-  "props",
-  "render-after-expand",
-  "load",
-  "render-content",
-  "highlight-current",
-  "default-expand-all",
-  "expand-on-click-node",
-  "check-on-click-node",
-  "auto-expand-parent",
-  "default-expanded-keys",
-  "show-checkbox",
-  "check-strictly",
-  "default-checked-keys",
-  "current-node-key",
-  "filter-node-method",
-  "accordion",
-  "indent",
-  "icon-class",
-  "lazy",
-  "draggable",
-  "allow-drag",
-  "allow-drop"
-];
-const elTreeEvents = [
-  "node-click",
-  "node-contextmenu",
-  "check-change",
-  "check",
-  "current-change",
-  "node-expand",
-  "node-collapse",
-  "node-drag-start",
-  "node-drag-enter",
-  "node-drag-leave",
-  "node-drag-over",
-  "node-drag-end",
-  "node-drop"
-];
-const filterProperties = (obj, allowProperties, allow = true) => {
-  if (isObject(obj)) {
-    let arr = allowProperties;
-    if (isString(allowProperties)) {
-      arr = arr.split(",");
-    }
-    const temp = {};
-    arr.forEach((key) => {
-      if (hasOwn(obj, key)) {
-        if (allow) {
-          temp[key] = obj[key];
-        } else {
-          if (!arr.includes(key)) {
-            temp[key] = obj[key];
-          }
-        }
-      }
-    });
-    return temp;
-  }
-  return obj;
-};
-const normalizeProps = (attrs) => {
-  const props = {};
-  for (const attrsKey in attrs) {
-    props[camelize(attrsKey)] = attrs[attrsKey];
-  }
-  return props;
-};
-const filterTableProperties = (obj) => {
-  return filterProperties(obj, elTableProperties);
-};
-const filterTableColumnProperties = (obj) => {
-  return filterProperties(obj, elTableColumnProperties);
-};
-const filterTableEvents = (obj) => {
-  return filterProperties(obj, elTableEvents);
-};
-const filterTreeProperties = (obj) => {
-  return filterProperties(obj, elTreeProperties);
-};
-const filterTreeEvents = (obj) => {
-  return filterProperties(obj, elTreeEvents);
-};
-const pathArgReplacer = (path = "", row) => {
-  const rw = row || {};
-  const p = path || "";
-  return p.replace(/{(.*?)}/g, (_, key) => {
-    if (key.indexOf(":")) {
-      const [k, defaultVal] = key.split(":");
-      return rw[k] ? rw[k] : defaultVal;
-    } else {
-      return rw[key] || "";
-    }
-  });
-};
-const fillPath = (path, args) => {
-  if (isFunction(path)) {
-    return pathArgReplacer(path(args), args);
-  } else if (isString(path)) {
-    return pathArgReplacer(path, args);
-  } else {
-    return null;
-  }
-};
-export {
-  filterTreeProperties as a,
-  filterTreeEvents as b,
-  assignReactiveProperties as c,
-  filterTableProperties as d,
-  filterTableEvents as e,
-  filterTableColumnProperties as f,
-  getInternetExplorerVersion as g,
-  getClass as h,
-  filterProperties as i,
-  findParent as j,
-  fillPath as k,
-  normalizeProps as n
-};