@revolugo/elements 5.5.1-beta.3 → 5.5.1-beta.30

package/dist/revolugo.vbtn.DrwUvQHj.min.js

@@ -0,0 +1,286 @@
+import { E as l, _ as h } from "./revolugo.vsheet.Cqbr0KfV.min.js";
+import { I as u } from "./revolugo.vuetify.BEdap6Ni.min.js";
+import { C as d, m as c, f as b } from "./revolugo.webcomponentwrapper.CwAC855u.min.js";
+import { h as n, i as v } from "./revolugo.revolugo-config.B9n_CElG.min.js";
+import { R as r, f as p, S as m } from "./revolugo.index.CnslRErc.min.js";
+import { P as f } from "./revolugo.index.mq4mKuqN.min.js";
+function a(t) {
+  try {
+    if (typeof document < "u") {
+      window.REVOLUGO_ELEMENTS_STYLES = window.REVOLUGO_ELEMENTS_STYLES || {
+        sheets: [],
+        components: []
+      };
+      const e = import.meta.url, s = e.slice(0, e.lastIndexOf("/") + 1) + t;
+      window.REVOLUGO_ELEMENTS_STYLES.sheets.push(s);
+      for (const i of REVOLUGO_ELEMENTS_STYLES.components)
+        i(s);
+      if (t.indexOf("fonts") >= 0) {
+        const i = document.createElement("link");
+        i.rel = "stylesheet", linK.href = s, document.head.appendChild(i);
+      }
+    }
+  } catch (e) {
+    console.error("[revolugo-elements] ", e);
+  }
+}
+const g = d.extend({
+  name: "v-progress-circular",
+  directives: {
+    intersect: u
+  },
+  props: {
+    button: Boolean,
+    indeterminate: Boolean,
+    rotate: {
+      type: [Number, String],
+      default: 0
+    },
+    size: {
+      type: [Number, String],
+      default: 32
+    },
+    width: {
+      type: [Number, String],
+      default: 4
+    },
+    value: {
+      type: [Number, String],
+      default: 0
+    }
+  },
+  data: () => ({
+    radius: 20,
+    isVisible: !0
+  }),
+  computed: {
+    calculatedSize() {
+      return Number(this.size) + (this.button ? 8 : 0);
+    },
+    circumference() {
+      return 2 * Math.PI * this.radius;
+    },
+    classes() {
+      return {
+        "v-progress-circular--visible": this.isVisible,
+        "v-progress-circular--indeterminate": this.indeterminate,
+        "v-progress-circular--button": this.button
+      };
+    },
+    normalizedValue() {
+      return this.value < 0 ? 0 : this.value > 100 ? 100 : parseFloat(this.value);
+    },
+    strokeDashArray() {
+      return Math.round(this.circumference * 1e3) / 1e3;
+    },
+    strokeDashOffset() {
+      return (100 - this.normalizedValue) / 100 * this.circumference + "px";
+    },
+    strokeWidth() {
+      return Number(this.width) / +this.size * this.viewBoxSize * 2;
+    },
+    styles() {
+      return {
+        height: n(this.calculatedSize),
+        width: n(this.calculatedSize)
+      };
+    },
+    svgStyles() {
+      return {
+        transform: `rotate(${Number(this.rotate)}deg)`
+      };
+    },
+    viewBoxSize() {
+      return this.radius / (1 - Number(this.width) / +this.size);
+    }
+  },
+  methods: {
+    genCircle(t, e) {
+      return this.$createElement("circle", {
+        class: `v-progress-circular__${t}`,
+        attrs: {
+          fill: "transparent",
+          cx: 2 * this.viewBoxSize,
+          cy: 2 * this.viewBoxSize,
+          r: this.radius,
+          "stroke-width": this.strokeWidth,
+          "stroke-dasharray": this.strokeDashArray,
+          "stroke-dashoffset": e
+        }
+      });
+    },
+    genSvg() {
+      const t = [this.indeterminate || this.genCircle("underlay", 0), this.genCircle("overlay", this.strokeDashOffset)];
+      return this.$createElement("svg", {
+        style: this.svgStyles,
+        attrs: {
+          xmlns: "http://www.w3.org/2000/svg",
+          viewBox: `${this.viewBoxSize} ${this.viewBoxSize} ${2 * this.viewBoxSize} ${2 * this.viewBoxSize}`
+        }
+      }, t);
+    },
+    genInfo() {
+      return this.$createElement("div", {
+        staticClass: "v-progress-circular__info"
+      }, this.$slots.default);
+    },
+    onObserve(t, e, s) {
+      this.isVisible = s;
+    }
+  },
+  render(t) {
+    return t("div", this.setTextColor(this.color, {
+      staticClass: "v-progress-circular",
+      attrs: {
+        role: "progressbar",
+        "aria-valuemin": 0,
+        "aria-valuemax": 100,
+        "aria-valuenow": this.indeterminate ? void 0 : this.normalizedValue
+      },
+      class: this.classes,
+      directives: [{
+        name: "intersect",
+        value: this.onObserve
+      }],
+      style: this.styles,
+      on: this.$listeners
+    }), [this.genSvg(), this.genInfo()]);
+  }
+}), S = c(
+  h,
+  r,
+  f,
+  m,
+  p("btnToggle"),
+  b("inputValue")
+  /* @vue/component */
+), C = S.extend().extend({
+  name: "v-btn",
+  props: {
+    activeClass: {
+      type: String,
+      default() {
+        return this.btnToggle ? this.btnToggle.activeClass : "";
+      }
+    },
+    block: Boolean,
+    depressed: Boolean,
+    fab: Boolean,
+    icon: Boolean,
+    loading: Boolean,
+    outlined: Boolean,
+    plain: Boolean,
+    retainFocusOnClick: Boolean,
+    rounded: Boolean,
+    tag: {
+      type: String,
+      default: "button"
+    },
+    text: Boolean,
+    tile: Boolean,
+    type: {
+      type: String,
+      default: "button"
+    },
+    value: null
+  },
+  data: () => ({
+    proxyClass: "v-btn--active"
+  }),
+  computed: {
+    classes() {
+      return {
+        "v-btn": !0,
+        ...r.options.computed.classes.call(this),
+        "v-btn--absolute": this.absolute,
+        "v-btn--block": this.block,
+        "v-btn--bottom": this.bottom,
+        "v-btn--disabled": this.disabled,
+        "v-btn--is-elevated": this.isElevated,
+        "v-btn--fab": this.fab,
+        "v-btn--fixed": this.fixed,
+        "v-btn--has-bg": this.hasBg,
+        "v-btn--icon": this.icon,
+        "v-btn--left": this.left,
+        "v-btn--loading": this.loading,
+        "v-btn--outlined": this.outlined,
+        "v-btn--plain": this.plain,
+        "v-btn--right": this.right,
+        "v-btn--round": this.isRound,
+        "v-btn--rounded": this.rounded,
+        "v-btn--router": this.to,
+        "v-btn--text": this.text,
+        "v-btn--tile": this.tile,
+        "v-btn--top": this.top,
+        ...this.themeClasses,
+        ...this.groupClasses,
+        ...this.elevationClasses,
+        ...this.sizeableClasses
+      };
+    },
+    computedElevation() {
+      if (!this.disabled)
+        return l.options.computed.computedElevation.call(this);
+    },
+    computedRipple() {
+      var t;
+      const e = this.icon || this.fab ? {
+        circle: !0
+      } : !0;
+      return this.disabled ? !1 : (t = this.ripple) !== null && t !== void 0 ? t : e;
+    },
+    hasBg() {
+      return !this.text && !this.plain && !this.outlined && !this.icon;
+    },
+    isElevated() {
+      return !this.icon && !this.text && !this.outlined && !this.depressed && !this.disabled && !this.plain && (this.elevation == null || Number(this.elevation) > 0);
+    },
+    isRound() {
+      return !!(this.icon || this.fab);
+    },
+    styles() {
+      return {
+        ...this.measurableStyles
+      };
+    }
+  },
+  created() {
+    [["flat", "text"], ["outline", "outlined"], ["round", "rounded"]].forEach(([e, s]) => {
+      this.$attrs.hasOwnProperty(e) && v(e, s, this);
+    });
+  },
+  methods: {
+    click(t) {
+      !this.retainFocusOnClick && !this.fab && t.detail && this.$el.blur(), this.$emit("click", t), this.btnToggle && this.toggle();
+    },
+    genContent() {
+      return this.$createElement("span", {
+        staticClass: "v-btn__content"
+      }, this.$slots.default);
+    },
+    genLoader() {
+      return this.$createElement("span", {
+        class: "v-btn__loader"
+      }, this.$slots.loader || [this.$createElement(g, {
+        props: {
+          indeterminate: !0,
+          size: 23,
+          width: 2
+        }
+      })]);
+    }
+  },
+  render(t) {
+    const e = [this.genContent(), this.loading && this.genLoader()], {
+      tag: s,
+      data: i
+    } = this.generateRouteLink(), o = this.hasBg ? this.setBackgroundColor : this.setTextColor;
+    return s === "button" && (i.attrs.type = this.type, i.attrs.disabled = this.disabled), i.attrs.value = ["string", "number"].includes(typeof this.value) ? this.value : JSON.stringify(this.value), t(s, this.disabled ? i : o(this.color, i), e);
+  }
+});
+a("css/revolugo.vbtn.By46MJOU.css");
+export {
+  C as _,
+  g as a
+};
+//# sourceMappingURL=revolugo.vbtn.DrwUvQHj.min.js.map

package/dist/revolugo.vcard.Bs6nQzOl.min.js

@@ -0,0 +1,80 @@
+import { _ as r } from "./revolugo.vsheet.Cqbr0KfV.min.js";
+import { L as n } from "./revolugo.index.Dx0TIvP-.min.js";
+import { R as i } from "./revolugo.index.CnslRErc.min.js";
+import { m as l } from "./revolugo.webcomponentwrapper.CwAC855u.min.js";
+function a(e) {
+  try {
+    if (typeof document < "u") {
+      window.REVOLUGO_ELEMENTS_STYLES = window.REVOLUGO_ELEMENTS_STYLES || {
+        sheets: [],
+        components: []
+      };
+      const s = import.meta.url, t = s.slice(0, s.lastIndexOf("/") + 1) + e;
+      window.REVOLUGO_ELEMENTS_STYLES.sheets.push(t);
+      for (const o of REVOLUGO_ELEMENTS_STYLES.components)
+        o(t);
+      if (e.indexOf("fonts") >= 0) {
+        const o = document.createElement("link");
+        o.rel = "stylesheet", linK.href = t, document.head.appendChild(o);
+      }
+    }
+  } catch (s) {
+    console.error("[revolugo-elements] ", s);
+  }
+}
+const u = l(n, i, r).extend({
+  name: "v-card",
+  props: {
+    flat: Boolean,
+    hover: Boolean,
+    img: String,
+    link: Boolean,
+    loaderHeight: {
+      type: [Number, String],
+      default: 4
+    },
+    raised: Boolean
+  },
+  computed: {
+    classes() {
+      return {
+        "v-card": !0,
+        ...i.options.computed.classes.call(this),
+        "v-card--flat": this.flat,
+        "v-card--hover": this.hover,
+        "v-card--link": this.isClickable,
+        "v-card--loading": this.loading,
+        "v-card--disabled": this.disabled,
+        "v-card--raised": this.raised,
+        ...r.options.computed.classes.call(this)
+      };
+    },
+    styles() {
+      const e = {
+        ...r.options.computed.styles.call(this)
+      };
+      return this.img && (e.background = `url("${this.img}") center center / cover no-repeat`), e;
+    }
+  },
+  methods: {
+    genProgress() {
+      const e = n.options.methods.genProgress.call(this);
+      return e ? this.$createElement("div", {
+        staticClass: "v-card__progress",
+        key: "progress"
+      }, [e]) : null;
+    }
+  },
+  render(e) {
+    const {
+      tag: s,
+      data: t
+    } = this.generateRouteLink();
+    return t.style = this.styles, this.isClickable && (t.attrs = t.attrs || {}, t.attrs.tabindex = 0), e(s, this.setBackgroundColor(this.color, t), [this.genProgress(), this.$slots.default]);
+  }
+});
+a("css/revolugo.vcard.DmB53ZNL.css");
+export {
+  u as _
+};
+//# sourceMappingURL=revolugo.vcard.Bs6nQzOl.min.js.map

package/dist/revolugo.vchip.CuCeqWzD.min.js

@@ -0,0 +1,157 @@
+import { m as r, f as c, T as h, C as p } from "./revolugo.webcomponentwrapper.CwAC855u.min.js";
+import { V as u } from "./revolugo.index.DxqmvtLl.min.js";
+import { f as d, R as l, S as f, _ as o } from "./revolugo.index.CnslRErc.min.js";
+import { i as m } from "./revolugo.revolugo-config.B9n_CElG.min.js";
+function n(e) {
+  try {
+    if (typeof document < "u") {
+      window.REVOLUGO_ELEMENTS_STYLES = window.REVOLUGO_ELEMENTS_STYLES || {
+        sheets: [],
+        components: []
+      };
+      const i = import.meta.url, s = i.slice(0, i.lastIndexOf("/") + 1) + e;
+      window.REVOLUGO_ELEMENTS_STYLES.sheets.push(s);
+      for (const t of REVOLUGO_ELEMENTS_STYLES.components)
+        t(s);
+      if (e.indexOf("fonts") >= 0) {
+        const t = document.createElement("link");
+        t.rel = "stylesheet", linK.href = s, document.head.appendChild(t);
+      }
+    }
+  } catch (i) {
+    console.error("[revolugo-elements] ", i);
+  }
+}
+const E = r(p, f, l, h, d("chipGroup"), c("inputValue")).extend({
+  name: "v-chip",
+  props: {
+    active: {
+      type: Boolean,
+      default: !0
+    },
+    activeClass: {
+      type: String,
+      default() {
+        return this.chipGroup ? this.chipGroup.activeClass : "";
+      }
+    },
+    close: Boolean,
+    closeIcon: {
+      type: String,
+      default: "$delete"
+    },
+    closeLabel: {
+      type: String,
+      default: "$vuetify.close"
+    },
+    disabled: Boolean,
+    draggable: Boolean,
+    filter: Boolean,
+    filterIcon: {
+      type: String,
+      default: "$complete"
+    },
+    label: Boolean,
+    link: Boolean,
+    outlined: Boolean,
+    pill: Boolean,
+    tag: {
+      type: String,
+      default: "span"
+    },
+    textColor: String,
+    value: null
+  },
+  data: () => ({
+    proxyClass: "v-chip--active"
+  }),
+  computed: {
+    classes() {
+      return {
+        "v-chip": !0,
+        ...l.options.computed.classes.call(this),
+        "v-chip--clickable": this.isClickable,
+        "v-chip--disabled": this.disabled,
+        "v-chip--draggable": this.draggable,
+        "v-chip--label": this.label,
+        "v-chip--link": this.isLink,
+        "v-chip--no-color": !this.color,
+        "v-chip--outlined": this.outlined,
+        "v-chip--pill": this.pill,
+        "v-chip--removable": this.hasClose,
+        ...this.themeClasses,
+        ...this.sizeableClasses,
+        ...this.groupClasses
+      };
+    },
+    hasClose() {
+      return !!this.close;
+    },
+    isClickable() {
+      return !!(l.options.computed.isClickable.call(this) || this.chipGroup);
+    }
+  },
+  created() {
+    [["outline", "outlined"], ["selected", "input-value"], ["value", "active"], ["@input", "@active.sync"]].forEach(([i, s]) => {
+      this.$attrs.hasOwnProperty(i) && m(i, s, this);
+    });
+  },
+  methods: {
+    click(e) {
+      this.$emit("click", e), this.chipGroup && this.toggle();
+    },
+    genFilter() {
+      const e = [];
+      return this.isActive && e.push(this.$createElement(o, {
+        staticClass: "v-chip__filter",
+        props: {
+          left: !0
+        }
+      }, this.filterIcon)), this.$createElement(u, e);
+    },
+    genClose() {
+      return this.$createElement(o, {
+        staticClass: "v-chip__close",
+        props: {
+          right: !0,
+          size: 18
+        },
+        attrs: {
+          "aria-label": this.$vuetify.lang.t(this.closeLabel)
+        },
+        on: {
+          click: (e) => {
+            e.stopPropagation(), e.preventDefault(), this.$emit("click:close"), this.$emit("update:active", !1);
+          }
+        }
+      }, this.closeIcon);
+    },
+    genContent() {
+      return this.$createElement("span", {
+        staticClass: "v-chip__content"
+      }, [this.filter && this.genFilter(), this.$slots.default, this.hasClose && this.genClose()]);
+    }
+  },
+  render(e) {
+    const i = [this.genContent()];
+    let {
+      tag: s,
+      data: t
+    } = this.generateRouteLink();
+    t.attrs = {
+      ...t.attrs,
+      draggable: this.draggable ? "true" : void 0,
+      tabindex: this.chipGroup && !this.disabled ? 0 : t.attrs.tabindex
+    }, t.directives.push({
+      name: "show",
+      value: this.active
+    }), t = this.setBackgroundColor(this.color, t);
+    const a = this.textColor || this.outlined && this.color;
+    return e(s, this.setTextColor(a, t), i);
+  }
+});
+n("css/revolugo.vchip.BdAdP6lC.css");
+export {
+  E as _
+};
+//# sourceMappingURL=revolugo.vchip.CuCeqWzD.min.js.map