@fewangsit/wangsvue 1.5.219-alpha.0 → 1.5.219-alpha.2

package/vendor/primevue/selectbutton/selectbutton.esm.es.js

@@ -1,11 +1,11 @@
-import { R as g } from "../ripple/ripple.esm.es.js";
-import { D as f, O as d } from "../utils/utils.esm.es.js";
-import { s as v } from "../basecomponent/basecomponent.esm.es.js";
-import { S } from "./style/selectbuttonstyle.esm.es.js";
-import { resolveDirective as A, createElementBlock as h, openBlock as p, mergeProps as b, Fragment as O, renderList as E, withDirectives as w, renderSlot as x, normalizeClass as K, createElementVNode as D, toDisplayString as I } from "vue";
-var V = {
+import { R as Ripple } from "../ripple/ripple.esm.es.js";
+import { D as DomHandler, O as ObjectUtils } from "../utils/utils.esm.es.js";
+import { s as script$2 } from "../basecomponent/basecomponent.esm.es.js";
+import { S as SelectButtonStyle } from "./style/selectbuttonstyle.esm.es.js";
+import { resolveDirective, createElementBlock, openBlock, mergeProps, Fragment, renderList, withDirectives, renderSlot, normalizeClass, createElementVNode, toDisplayString } from "vue";
+var script$1 = {
   name: "BaseSelectButton",
-  extends: v,
+  "extends": script$2,
   props: {
     modelValue: null,
     options: Array,
@@ -15,264 +15,310 @@ var V = {
     multiple: Boolean,
     unselectable: {
       type: Boolean,
-      default: !0
+      "default": true
     },
     allowEmpty: {
       type: Boolean,
-      default: !0
+      "default": true
     },
     invalid: {
       type: Boolean,
-      default: !1
+      "default": false
     },
     disabled: Boolean,
     dataKey: null,
     ariaLabelledby: {
       type: String,
-      default: null
+      "default": null
     }
   },
-  style: S,
-  provide: function() {
+  style: SelectButtonStyle,
+  provide: function provide() {
     return {
       $parentInstance: this
     };
   }
 };
-function T(t, e) {
-  var n = typeof Symbol < "u" && t[Symbol.iterator] || t["@@iterator"];
-  if (!n) {
-    if (Array.isArray(t) || (n = y(t)) || e) {
-      n && (t = n);
-      var l = 0, u = function() {
+function _createForOfIteratorHelper(o, allowArrayLike) {
+  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+  if (!it) {
+    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike) {
+      if (it) o = it;
+      var i = 0;
+      var F = function F2() {
       };
-      return { s: u, n: function() {
-        return l >= t.length ? { done: !0 } : { done: !1, value: t[l++] };
-      }, e: function(s) {
-        throw s;
-      }, f: u };
+      return { s: F, n: function n() {
+        if (i >= o.length) return { done: true };
+        return { done: false, value: o[i++] };
+      }, e: function e(_e) {
+        throw _e;
+      }, f: F };
     }
-    throw new TypeError(`Invalid attempt to iterate non-iterable instance.
-In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
   }
-  var r = !0, o = !1, i;
-  return { s: function() {
-    n = n.call(t);
-  }, n: function() {
-    var s = n.next();
-    return r = s.done, s;
-  }, e: function(s) {
-    o = !0, i = s;
-  }, f: function() {
+  var normalCompletion = true, didErr = false, err;
+  return { s: function s() {
+    it = it.call(o);
+  }, n: function n() {
+    var step = it.next();
+    normalCompletion = step.done;
+    return step;
+  }, e: function e(_e2) {
+    didErr = true;
+    err = _e2;
+  }, f: function f() {
     try {
-      !r && n.return != null && n.return();
+      if (!normalCompletion && it["return"] != null) it["return"]();
     } finally {
-      if (o) throw i;
+      if (didErr) throw err;
     }
   } };
 }
-function B(t) {
-  return F(t) || k(t) || y(t) || L();
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
 }
-function L() {
-  throw new TypeError(`Invalid attempt to spread non-iterable instance.
-In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
-function y(t, e) {
-  if (t) {
-    if (typeof t == "string") return m(t, e);
-    var n = Object.prototype.toString.call(t).slice(8, -1);
-    if (n === "Object" && t.constructor && (n = t.constructor.name), n === "Map" || n === "Set") return Array.from(t);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return m(t, e);
-  }
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
 }
-function k(t) {
-  if (typeof Symbol < "u" && t[Symbol.iterator] != null || t["@@iterator"] != null) return Array.from(t);
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
 }
-function F(t) {
-  if (Array.isArray(t)) return m(t);
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
 }
-function m(t, e) {
-  (e == null || e > t.length) && (e = t.length);
-  for (var n = 0, l = new Array(e); n < e; n++) l[n] = t[n];
-  return l;
+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;
 }
-var q = {
+var script = {
   name: "SelectButton",
-  extends: V,
-  inheritAttrs: !1,
+  "extends": script$1,
+  inheritAttrs: false,
   emits: ["update:modelValue", "focus", "blur", "change"],
-  data: function() {
+  data: function data() {
     return {
       focusedIndex: 0
     };
   },
-  mounted: function() {
+  mounted: function mounted() {
     this.defaultTabIndexes();
   },
   methods: {
-    defaultTabIndexes: function() {
-      for (var e = f.find(this.$refs.container, '[data-pc-section="button"]'), n = f.findSingle(this.$refs.container, '[data-p-highlight="true"]'), l = 0; l < e.length; l++)
-        (f.getAttribute(e[l], "data-p-highlight") === !0 && d.equals(e[l], n) || n === null && l == 0) && (this.focusedIndex = l);
+    defaultTabIndexes: function defaultTabIndexes() {
+      var opts = DomHandler.find(this.$refs.container, '[data-pc-section="button"]');
+      var firstHighlight = DomHandler.findSingle(this.$refs.container, '[data-p-highlight="true"]');
+      for (var i = 0; i < opts.length; i++) {
+        if (DomHandler.getAttribute(opts[i], "data-p-highlight") === true && ObjectUtils.equals(opts[i], firstHighlight) || firstHighlight === null && i == 0) {
+          this.focusedIndex = i;
+        }
+      }
     },
-    getOptionLabel: function(e) {
-      return this.optionLabel ? d.resolveFieldData(e, this.optionLabel) : e;
+    getOptionLabel: function getOptionLabel(option) {
+      return this.optionLabel ? ObjectUtils.resolveFieldData(option, this.optionLabel) : option;
     },
-    getOptionValue: function(e) {
-      return this.optionValue ? d.resolveFieldData(e, this.optionValue) : e;
+    getOptionValue: function getOptionValue(option) {
+      return this.optionValue ? ObjectUtils.resolveFieldData(option, this.optionValue) : option;
     },
-    getOptionRenderKey: function(e) {
-      return this.dataKey ? d.resolveFieldData(e, this.dataKey) : this.getOptionLabel(e);
+    getOptionRenderKey: function getOptionRenderKey(option) {
+      return this.dataKey ? ObjectUtils.resolveFieldData(option, this.dataKey) : this.getOptionLabel(option);
     },
-    getPTOptions: function(e, n) {
-      return this.ptm(n, {
+    getPTOptions: function getPTOptions(option, key) {
+      return this.ptm(key, {
         context: {
-          active: this.isSelected(e),
-          disabled: this.isOptionDisabled(e),
-          option: e
+          active: this.isSelected(option),
+          disabled: this.isOptionDisabled(option),
+          option
         }
       });
     },
-    isOptionDisabled: function(e) {
-      return this.optionDisabled ? d.resolveFieldData(e, this.optionDisabled) : !1;
+    isOptionDisabled: function isOptionDisabled(option) {
+      return this.optionDisabled ? ObjectUtils.resolveFieldData(option, this.optionDisabled) : false;
     },
-    onOptionSelect: function(e, n, l) {
-      var u = this;
-      if (!(this.disabled || this.isOptionDisabled(n))) {
-        var r = this.isSelected(n);
-        if (!(r && !(this.unselectable && this.allowEmpty))) {
-          var o = this.getOptionValue(n), i;
-          this.multiple ? r ? i = this.modelValue.filter(function(a) {
-            return !d.equals(a, o, u.equalityKey);
-          }) : i = this.modelValue ? [].concat(B(this.modelValue), [o]) : [o] : i = r ? null : o, this.focusedIndex = l, this.$emit("update:modelValue", i), this.$emit("change", {
-            event: e,
-            value: i
-          });
-        }
+    onOptionSelect: function onOptionSelect(event, option, index) {
+      var _this = this;
+      if (this.disabled || this.isOptionDisabled(option)) {
+        return;
+      }
+      var selected = this.isSelected(option);
+      if (selected && !(this.unselectable && this.allowEmpty)) {
+        return;
       }
+      var optionValue = this.getOptionValue(option);
+      var newValue;
+      if (this.multiple) {
+        if (selected) newValue = this.modelValue.filter(function(val) {
+          return !ObjectUtils.equals(val, optionValue, _this.equalityKey);
+        });
+        else newValue = this.modelValue ? [].concat(_toConsumableArray(this.modelValue), [optionValue]) : [optionValue];
+      } else {
+        newValue = selected ? null : optionValue;
+      }
+      this.focusedIndex = index;
+      this.$emit("update:modelValue", newValue);
+      this.$emit("change", {
+        event,
+        value: newValue
+      });
     },
-    isSelected: function(e) {
-      var n = !1, l = this.getOptionValue(e);
+    isSelected: function isSelected(option) {
+      var selected = false;
+      var optionValue = this.getOptionValue(option);
       if (this.multiple) {
         if (this.modelValue) {
-          var u = T(this.modelValue), r;
+          var _iterator = _createForOfIteratorHelper(this.modelValue), _step;
           try {
-            for (u.s(); !(r = u.n()).done; ) {
-              var o = r.value;
-              if (d.equals(o, l, this.equalityKey)) {
-                n = !0;
+            for (_iterator.s(); !(_step = _iterator.n()).done; ) {
+              var val = _step.value;
+              if (ObjectUtils.equals(val, optionValue, this.equalityKey)) {
+                selected = true;
                 break;
               }
             }
-          } catch (i) {
-            u.e(i);
+          } catch (err) {
+            _iterator.e(err);
           } finally {
-            u.f();
+            _iterator.f();
           }
         }
-      } else
-        n = d.equals(this.modelValue, l, this.equalityKey);
-      return n;
+      } else {
+        selected = ObjectUtils.equals(this.modelValue, optionValue, this.equalityKey);
+      }
+      return selected;
     },
-    onKeydown: function(e, n, l) {
-      switch (e.code) {
+    onKeydown: function onKeydown(event, option, index) {
+      switch (event.code) {
         case "Space": {
-          this.onOptionSelect(e, n, l), e.preventDefault();
+          this.onOptionSelect(event, option, index);
+          event.preventDefault();
           break;
         }
         case "ArrowDown":
         case "ArrowRight": {
-          this.onArrowRightKey(e.target), e.preventDefault();
+          this.onArrowRightKey(event.target);
+          event.preventDefault();
           break;
         }
         case "ArrowUp":
         case "ArrowLeft": {
-          this.onArrowLeftKey(e.target), e.preventDefault();
+          this.onArrowLeftKey(event.target);
+          event.preventDefault();
           break;
         }
       }
     },
-    onArrowRightKey: function(e) {
-      var n = this.findNextElement(e);
-      n && (this.focusedIndex = d.findIndexInList(n, this.findAllElements()), f.focus(n));
+    onArrowRightKey: function onArrowRightKey(target) {
+      var nextEl = this.findNextElement(target);
+      if (nextEl) {
+        this.focusedIndex = ObjectUtils.findIndexInList(nextEl, this.findAllElements());
+        DomHandler.focus(nextEl);
+      }
     },
-    onArrowLeftKey: function(e) {
-      var n = this.findPrevElement(e);
-      n && (this.focusedIndex = d.findIndexInList(n, this.findAllElements()), f.focus(n));
+    onArrowLeftKey: function onArrowLeftKey(target) {
+      var prevEl = this.findPrevElement(target);
+      if (prevEl) {
+        this.focusedIndex = ObjectUtils.findIndexInList(prevEl, this.findAllElements());
+        DomHandler.focus(prevEl);
+      }
     },
-    findAllElements: function() {
-      return f.find(this.$refs.container, '[data-pc-section="button"]');
+    findAllElements: function findAllElements() {
+      return DomHandler.find(this.$refs.container, '[data-pc-section="button"]');
     },
-    findNextElement: function(e) {
-      return e.nextElementSibling ? f.getAttribute(e.nextElementSibling, "data-p-disabled") ? this.findNextElement(e.nextElementSibling) : e.nextElementSibling : null;
+    findNextElement: function findNextElement(target) {
+      if (target.nextElementSibling) {
+        if (DomHandler.getAttribute(target.nextElementSibling, "data-p-disabled")) {
+          return this.findNextElement(target.nextElementSibling);
+        }
+        return target.nextElementSibling;
+      }
+      return null;
     },
-    findPrevElement: function(e) {
-      return e.previousElementSibling ? f.getAttribute(e.previousElementSibling, "data-p-disabled") ? this.findPrevElement(e.previousElementSibling) : e.previousElementSibling : null;
+    findPrevElement: function findPrevElement(target) {
+      if (target.previousElementSibling) {
+        if (DomHandler.getAttribute(target.previousElementSibling, "data-p-disabled")) {
+          return this.findPrevElement(target.previousElementSibling);
+        }
+        return target.previousElementSibling;
+      }
+      return null;
     },
-    onFocus: function(e) {
-      this.$emit("focus", e);
+    onFocus: function onFocus(event) {
+      this.$emit("focus", event);
     },
-    onBlur: function(e, n) {
-      e.target && e.relatedTarget && e.target.parentElement !== e.relatedTarget.parentElement && this.defaultTabIndexes(), this.$emit("blur", e, n);
+    onBlur: function onBlur(event, option) {
+      if (event.target && event.relatedTarget && event.target.parentElement !== event.relatedTarget.parentElement) {
+        this.defaultTabIndexes();
+      }
+      this.$emit("blur", event, option);
     },
-    findTabindex: function(e, n) {
-      return this.disabled || this.isOptionDisabled(e) || n !== this.focusedIndex ? "-1" : "0";
+    findTabindex: function findTabindex(option, index) {
+      return this.disabled || this.isOptionDisabled(option) || index !== this.focusedIndex ? "-1" : "0";
     }
   },
   computed: {
-    equalityKey: function() {
+    equalityKey: function equalityKey() {
       return this.optionValue ? null : this.dataKey;
     }
   },
   directives: {
-    ripple: g
+    ripple: Ripple
   }
-}, P = ["aria-labelledby"], R = ["tabindex", "aria-label", "role", "aria-checked", "aria-disabled", "onClick", "onKeydown", "onBlur", "data-p-highlight", "data-p-disabled"];
-function C(t, e, n, l, u, r) {
-  var o = A("ripple");
-  return p(), h("div", b({
+};
+var _hoisted_1 = ["aria-labelledby"];
+var _hoisted_2 = ["tabindex", "aria-label", "role", "aria-checked", "aria-disabled", "onClick", "onKeydown", "onBlur", "data-p-highlight", "data-p-disabled"];
+function render(_ctx, _cache, $props, $setup, $data, $options) {
+  var _directive_ripple = resolveDirective("ripple");
+  return openBlock(), createElementBlock("div", mergeProps({
     ref: "container",
-    class: t.cx("root"),
+    "class": _ctx.cx("root"),
     role: "group",
-    "aria-labelledby": t.ariaLabelledby
-  }, t.ptmi("root")), [(p(!0), h(O, null, E(t.options, function(i, a) {
-    return w((p(), h("div", b({
-      key: r.getOptionRenderKey(i),
-      tabindex: r.findTabindex(i, a),
-      "aria-label": r.getOptionLabel(i),
-      role: t.multiple ? "checkbox" : "radio",
-      "aria-checked": r.isSelected(i),
-      "aria-disabled": r.isOptionDisabled(i),
-      class: t.cx("button", {
-        option: i
+    "aria-labelledby": _ctx.ariaLabelledby
+  }, _ctx.ptmi("root")), [(openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.options, function(option, i) {
+    return withDirectives((openBlock(), createElementBlock("div", mergeProps({
+      key: $options.getOptionRenderKey(option),
+      tabindex: $options.findTabindex(option, i),
+      "aria-label": $options.getOptionLabel(option),
+      role: _ctx.multiple ? "checkbox" : "radio",
+      "aria-checked": $options.isSelected(option),
+      "aria-disabled": $options.isOptionDisabled(option),
+      "class": _ctx.cx("button", {
+        option
       }),
-      onClick: function(c) {
-        return r.onOptionSelect(c, i, a);
+      onClick: function onClick($event) {
+        return $options.onOptionSelect($event, option, i);
       },
-      onKeydown: function(c) {
-        return r.onKeydown(c, i, a);
+      onKeydown: function onKeydown2($event) {
+        return $options.onKeydown($event, option, i);
       },
-      onFocus: e[0] || (e[0] = function(s) {
-        return r.onFocus(s);
+      onFocus: _cache[0] || (_cache[0] = function($event) {
+        return $options.onFocus($event);
       }),
-      onBlur: function(c) {
-        return r.onBlur(c, i);
+      onBlur: function onBlur2($event) {
+        return $options.onBlur($event, option);
       }
-    }, r.getPTOptions(i, "button"), {
-      "data-p-highlight": r.isSelected(i),
-      "data-p-disabled": r.isOptionDisabled(i)
-    }), [x(t.$slots, "option", {
-      option: i,
-      index: a,
-      class: K(t.cx("label"))
+    }, $options.getPTOptions(option, "button"), {
+      "data-p-highlight": $options.isSelected(option),
+      "data-p-disabled": $options.isOptionDisabled(option)
+    }), [renderSlot(_ctx.$slots, "option", {
+      option,
+      index: i,
+      "class": normalizeClass(_ctx.cx("label"))
     }, function() {
-      return [D("span", b({
-        class: t.cx("label")
-      }, r.getPTOptions(i, "label")), I(r.getOptionLabel(i)), 17)];
-    })], 16, R)), [[o]]);
-  }), 128))], 16, P);
+      return [createElementVNode("span", mergeProps({
+        "class": _ctx.cx("label")
+      }, $options.getPTOptions(option, "label")), toDisplayString($options.getOptionLabel(option)), 17)];
+    })], 16, _hoisted_2)), [[_directive_ripple]]);
+  }), 128))], 16, _hoisted_1);
 }
-q.render = C;
+script.render = render;
 export {
-  q as s
+  script as s
 };

package/vendor/primevue/selectbutton/style/selectbuttonstyle.esm.es.js

@@ -1,24 +1,25 @@
-import { B as p } from "../../base/style/basestyle.esm.es.js";
-var s = {
-  root: function(e) {
-    var t = e.props;
+import { B as BaseStyle } from "../../base/style/basestyle.esm.es.js";
+var classes = {
+  root: function root(_ref) {
+    var props = _ref.props;
     return ["p-selectbutton p-button-group p-component", {
-      "p-disabled": t.disabled,
-      "p-invalid": t.invalid
+      "p-disabled": props.disabled,
+      "p-invalid": props.invalid
     }];
   },
-  button: function(e) {
-    var t = e.instance, n = e.option;
+  button: function button(_ref2) {
+    var instance = _ref2.instance, option = _ref2.option;
     return ["p-button p-component", {
-      "p-highlight": t.isSelected(n),
-      "p-disabled": t.isOptionDisabled(n)
+      "p-highlight": instance.isSelected(option),
+      "p-disabled": instance.isOptionDisabled(option)
     }];
   },
   label: "p-button-label"
-}, i = p.extend({
+};
+var SelectButtonStyle = BaseStyle.extend({
   name: "selectbutton",
-  classes: s
+  classes
 });
 export {
-  i as S
+  SelectButtonStyle as S
 };

package/vendor/primevue/skeleton/skeleton.esm.es.js

@@ -1,52 +1,54 @@
-import { s as r } from "../basecomponent/basecomponent.esm.es.js";
-import { S as i } from "./style/skeletonstyle.esm.es.js";
-import { createElementBlock as n, openBlock as s, mergeProps as a } from "vue";
-var o = {
+import { s as script$2 } from "../basecomponent/basecomponent.esm.es.js";
+import { S as SkeletonStyle } from "./style/skeletonstyle.esm.es.js";
+import { createElementBlock, openBlock, mergeProps } from "vue";
+var script$1 = {
   name: "BaseSkeleton",
-  extends: r,
+  "extends": script$2,
   props: {
     shape: {
       type: String,
-      default: "rectangle"
+      "default": "rectangle"
     },
     size: {
       type: String,
-      default: null
+      "default": null
     },
     width: {
       type: String,
-      default: "100%"
+      "default": "100%"
     },
     height: {
       type: String,
-      default: "1rem"
+      "default": "1rem"
     },
     borderRadius: {
       type: String,
-      default: null
+      "default": null
     },
     animation: {
       type: String,
-      default: "wave"
+      "default": "wave"
     }
   },
-  style: i,
-  provide: function() {
+  style: SkeletonStyle,
+  provide: function provide() {
     return {
       $parentInstance: this
     };
   }
-}, d = {
+};
+var script = {
   name: "Skeleton",
-  extends: o,
-  inheritAttrs: !1,
+  "extends": script$1,
+  inheritAttrs: false,
   computed: {
-    containerStyle: function() {
-      return this.size ? {
+    containerStyle: function containerStyle() {
+      if (this.size) return {
         width: this.size,
         height: this.size,
         borderRadius: this.borderRadius
-      } : {
+      };
+      else return {
         width: this.width,
         height: this.height,
         borderRadius: this.borderRadius
@@ -54,14 +56,14 @@ var o = {
     }
   }
 };
-function l(e, p, h, u, c, t) {
-  return s(), n("div", a({
-    class: e.cx("root"),
-    style: [e.sx("root"), t.containerStyle],
+function render(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("div", mergeProps({
+    "class": _ctx.cx("root"),
+    style: [_ctx.sx("root"), $options.containerStyle],
     "aria-hidden": "true"
-  }, e.ptmi("root")), null, 16);
+  }, _ctx.ptmi("root")), null, 16);
 }
-d.render = l;
+script.render = render;
 export {
-  d as s
+  script as s
 };