@revolugo/elements 5.5.2 → 5.5.3-beta.0

package/dist/revolugo.index.sTY3URQu.min.js

@@ -0,0 +1,390 @@
+import { B as p } from "./revolugo.index.Cn5YTzy6.min.js";
+import { m as f, T as g, C as m } from "./revolugo.webcomponentwrapper.-wnE6sKX.min.js";
+import { V as r } from "./revolugo.i18n.DF3U6VhD.min.js";
+import { v, b as x, h as C, q as S, t as b } from "./revolugo.revolugo-config.Bs_HF2Eu.min.js";
+import { r as y } from "./revolugo.vuetify.yojzDMFk.min.js";
+function u(t) {
+  try {
+    if (typeof document < "u") {
+      window.REVOLUGO_ELEMENTS_STYLES = window.REVOLUGO_ELEMENTS_STYLES || {
+        sheets: [],
+        components: []
+      };
+      const e = import.meta.url, i = e.slice(0, e.lastIndexOf("/") + 1) + t;
+      window.REVOLUGO_ELEMENTS_STYLES.sheets.push(i);
+      for (const s of REVOLUGO_ELEMENTS_STYLES.components)
+        s(i);
+      if (t.indexOf("fonts") >= 0) {
+        const s = document.createElement("link");
+        s.rel = "stylesheet", linK.href = i, document.head.appendChild(s);
+      }
+    }
+  } catch (e) {
+    console.error("[revolugo-elements] ", e);
+  }
+}
+const k = r.extend({
+  name: "sizeable",
+  props: {
+    large: Boolean,
+    small: Boolean,
+    xLarge: Boolean,
+    xSmall: Boolean
+  },
+  computed: {
+    medium() {
+      return !this.xSmall && !this.small && !this.large && !this.xLarge;
+    },
+    sizeableClasses() {
+      return {
+        "v-size--x-small": this.xSmall,
+        "v-size--small": this.small,
+        "v-size--default": this.medium,
+        "v-size--large": this.large,
+        "v-size--x-large": this.xLarge
+      };
+    }
+  }
+});
+var a;
+(function(t) {
+  t.xSmall = "12px", t.small = "16px", t.default = "24px", t.medium = "28px", t.large = "36px", t.xLarge = "40px";
+})(a || (a = {}));
+function L(t) {
+  return ["fas", "far", "fal", "fab", "fad", "fak"].some((e) => t.includes(e));
+}
+function $(t) {
+  return /^[mzlhvcsqta]\s*[-+.0-9][^mlhvzcsqta]+/i.test(t) && /[\dz]$/i.test(t) && t.length > 4;
+}
+const c = f(
+  p,
+  m,
+  k,
+  g
+  /* @vue/component */
+).extend({
+  name: "v-icon",
+  props: {
+    dense: Boolean,
+    disabled: Boolean,
+    left: Boolean,
+    right: Boolean,
+    size: [Number, String],
+    tag: {
+      type: String,
+      required: !1,
+      default: "i"
+    }
+  },
+  computed: {
+    medium() {
+      return !1;
+    },
+    hasClickListener() {
+      return !!(this.listeners$.click || this.listeners$["!click"]);
+    }
+  },
+  methods: {
+    getIcon() {
+      let t = "";
+      return this.$slots.default && (t = this.$slots.default[0].text.trim()), v(this, t);
+    },
+    getSize() {
+      const t = {
+        xSmall: this.xSmall,
+        small: this.small,
+        medium: this.medium,
+        large: this.large,
+        xLarge: this.xLarge
+      }, e = x(t).find((i) => t[i]);
+      return e && a[e] || C(this.size);
+    },
+    // Component data for both font icon and SVG wrapper span
+    getDefaultData() {
+      return {
+        staticClass: "v-icon notranslate",
+        class: {
+          "v-icon--disabled": this.disabled,
+          "v-icon--left": this.left,
+          "v-icon--link": this.hasClickListener,
+          "v-icon--right": this.right,
+          "v-icon--dense": this.dense
+        },
+        attrs: {
+          "aria-hidden": !this.hasClickListener,
+          disabled: this.hasClickListener && this.disabled,
+          type: this.hasClickListener ? "button" : void 0,
+          ...this.attrs$
+        },
+        on: this.listeners$
+      };
+    },
+    getSvgWrapperData() {
+      const t = this.getSize(), e = {
+        ...this.getDefaultData(),
+        style: t ? {
+          fontSize: t,
+          height: t,
+          width: t
+        } : void 0
+      };
+      return this.applyColors(e), e;
+    },
+    applyColors(t) {
+      t.class = {
+        ...t.class,
+        ...this.themeClasses
+      }, this.setTextColor(this.color, t);
+    },
+    renderFontIcon(t, e) {
+      const i = [], s = this.getDefaultData();
+      let n = "material-icons";
+      const o = t.indexOf("-"), l = o <= -1;
+      l ? i.push(t) : (n = t.slice(0, o), L(n) && (n = "")), s.class[n] = !0, s.class[t] = !l;
+      const h = this.getSize();
+      return h && (s.style = {
+        fontSize: h
+      }), this.applyColors(s), e(this.hasClickListener ? "button" : this.tag, s, i);
+    },
+    renderSvgIcon(t, e) {
+      const i = {
+        class: "v-icon__svg",
+        attrs: {
+          xmlns: "http://www.w3.org/2000/svg",
+          viewBox: "0 0 24 24",
+          role: "img",
+          "aria-hidden": !0
+        }
+      }, s = this.getSize();
+      return s && (i.style = {
+        fontSize: s,
+        height: s,
+        width: s
+      }), e(this.hasClickListener ? "button" : "span", this.getSvgWrapperData(), [e("svg", i, [e("path", {
+        attrs: {
+          d: t
+        }
+      })])]);
+    },
+    renderSvgIconComponent(t, e) {
+      const i = {
+        class: {
+          "v-icon__component": !0
+        }
+      }, s = this.getSize();
+      s && (i.style = {
+        fontSize: s,
+        height: s,
+        width: s
+      }), this.applyColors(i);
+      const n = t.component;
+      return i.props = t.props, i.nativeOn = i.on, e(this.hasClickListener ? "button" : "span", this.getSvgWrapperData(), [e(n, i)]);
+    }
+  },
+  render(t) {
+    const e = this.getIcon();
+    return typeof e == "string" ? $(e) ? this.renderSvgIcon(e, t) : this.renderFontIcon(e, t) : this.renderSvgIconComponent(e, t);
+  }
+}), D = r.extend({
+  name: "v-icon",
+  $_wrapperFor: c,
+  functional: !0,
+  render(t, {
+    data: e,
+    children: i
+  }) {
+    let s = "";
+    return e.domProps && (s = e.domProps.textContent || e.domProps.innerHTML || s, delete e.domProps.textContent, delete e.domProps.innerHTML), t(c, e, s ? [s] : i);
+  }
+});
+function d(t, e) {
+  return () => S(`The ${t} component must be used inside a ${e}`);
+}
+function z(t, e, i) {
+  const s = e && i ? {
+    register: d(e, i),
+    unregister: d(e, i)
+  } : null;
+  return r.extend({
+    name: "registrable-inject",
+    inject: {
+      [t]: {
+        default: s
+      }
+    }
+  });
+}
+function R(t, e = !1) {
+  return r.extend({
+    name: "registrable-provide",
+    provide() {
+      return {
+        [t]: e ? this : {
+          register: this.register,
+          unregister: this.unregister
+        }
+      };
+    }
+  });
+}
+function B(t, e, i) {
+  return z(t, e, i).extend({
+    name: "groupable",
+    props: {
+      activeClass: {
+        type: String,
+        default() {
+          if (this[t])
+            return this[t].activeClass;
+        }
+      },
+      disabled: Boolean
+    },
+    data() {
+      return {
+        isActive: !1
+      };
+    },
+    computed: {
+      groupClasses() {
+        return this.activeClass ? {
+          [this.activeClass]: this.isActive
+        } : {};
+      }
+    },
+    created() {
+      this[t] && this[t].register(this);
+    },
+    beforeDestroy() {
+      this[t] && this[t].unregister(this);
+    },
+    methods: {
+      toggle(s) {
+        if (this.disabled && s) {
+          s.preventDefault();
+          return;
+        }
+        this.$emit("change");
+      }
+    }
+  });
+}
+B("itemGroup");
+const A = r.extend({
+  name: "routable",
+  directives: {
+    Ripple: y
+  },
+  props: {
+    activeClass: String,
+    append: Boolean,
+    disabled: Boolean,
+    exact: {
+      type: Boolean,
+      default: void 0
+    },
+    exactPath: Boolean,
+    exactActiveClass: String,
+    link: Boolean,
+    href: [String, Object],
+    to: [String, Object],
+    nuxt: Boolean,
+    replace: Boolean,
+    ripple: {
+      type: [Boolean, Object],
+      default: null
+    },
+    tag: String,
+    target: String
+  },
+  data: () => ({
+    isActive: !1,
+    proxyClass: ""
+  }),
+  computed: {
+    classes() {
+      const t = {};
+      return this.to || (this.activeClass && (t[this.activeClass] = this.isActive), this.proxyClass && (t[this.proxyClass] = this.isActive)), t;
+    },
+    computedRipple() {
+      var t;
+      return (t = this.ripple) !== null && t !== void 0 ? t : !this.disabled && this.isClickable;
+    },
+    isClickable() {
+      return this.disabled ? !1 : !!(this.isLink || this.$listeners.click || this.$listeners["!click"] || this.$attrs.tabindex);
+    },
+    isLink() {
+      return this.to || this.href || this.link;
+    },
+    styles: () => ({})
+  },
+  watch: {
+    $route: "onRouteChange"
+  },
+  mounted() {
+    this.onRouteChange();
+  },
+  methods: {
+    generateRouteLink() {
+      let t = this.exact, e;
+      const i = {
+        attrs: {
+          tabindex: "tabindex" in this.$attrs ? this.$attrs.tabindex : void 0
+        },
+        class: this.classes,
+        style: this.styles,
+        props: {},
+        directives: [{
+          name: "ripple",
+          value: this.computedRipple
+        }],
+        [this.to ? "nativeOn" : "on"]: {
+          ...this.$listeners,
+          ..."click" in this ? {
+            click: this.click
+          } : void 0
+          // #14447
+        },
+        ref: "link"
+      };
+      if (typeof this.exact > "u" && (t = this.to === "/" || this.to === Object(this.to) && this.to.path === "/"), this.to) {
+        let s = this.activeClass, n = this.exactActiveClass || s;
+        this.proxyClass && (s = `${s} ${this.proxyClass}`.trim(), n = `${n} ${this.proxyClass}`.trim()), e = this.nuxt ? "nuxt-link" : "router-link", Object.assign(i.props, {
+          to: this.to,
+          exact: t,
+          exactPath: this.exactPath,
+          activeClass: s,
+          exactActiveClass: n,
+          append: this.append,
+          replace: this.replace
+        });
+      } else
+        e = this.href && "a" || this.tag || "div", e === "a" && this.href && (i.attrs.href = this.href);
+      return this.target && (i.attrs.target = this.target), {
+        tag: e,
+        data: i
+      };
+    },
+    onRouteChange() {
+      if (!this.to || !this.$refs.link || !this.$route)
+        return;
+      const t = `${this.activeClass || ""} ${this.proxyClass || ""}`.trim(), e = `${this.exactActiveClass || ""} ${this.proxyClass || ""}`.trim() || t, i = "_vnode.data.class." + (this.exact ? e : t);
+      this.$nextTick(() => {
+        !b(this.$refs.link, i) === this.isActive && this.toggle();
+      });
+    },
+    toggle() {
+      this.isActive = !this.isActive;
+    }
+  }
+});
+u("css/revolugo.index.BMkl7a3p.css");
+export {
+  A as R,
+  k as S,
+  D as _,
+  B as f,
+  z as i,
+  R as p
+};
+//# sourceMappingURL=revolugo.index.sTY3URQu.min.js.map

package/dist/revolugo.index.tY8MFB9m.min.js

@@ -0,0 +1,161 @@
+import { V as l } from "./revolugo.vinput.CDpcVlCU.min.js";
+import { r as a } from "./revolugo.vuetify.yojzDMFk.min.js";
+import { V as u } from "./revolugo.i18n.DF3U6VhD.min.js";
+import { C as o } from "./revolugo.index.CQC_pZJn.min.js";
+import { m as h } from "./revolugo.webcomponentwrapper.-wnE6sKX.min.js";
+function r(e) {
+  try {
+    if (typeof document < "u") {
+      window.REVOLUGO_ELEMENTS_STYLES = window.REVOLUGO_ELEMENTS_STYLES || {
+        sheets: [],
+        components: []
+      };
+      const t = import.meta.url, i = t.slice(0, t.lastIndexOf("/") + 1) + e;
+      window.REVOLUGO_ELEMENTS_STYLES.sheets.push(i);
+      for (const s of REVOLUGO_ELEMENTS_STYLES.components)
+        s(i);
+      if (e.indexOf("fonts") >= 0) {
+        const s = document.createElement("link");
+        s.rel = "stylesheet", linK.href = i, document.head.appendChild(s);
+      }
+    }
+  } catch (t) {
+    console.error("[revolugo-elements] ", t);
+  }
+}
+const p = u.extend({
+  name: "rippleable",
+  directives: {
+    ripple: a
+  },
+  props: {
+    ripple: {
+      type: [Boolean, Object],
+      default: !0
+    }
+  },
+  methods: {
+    genRipple(e = {}) {
+      return this.ripple ? (e.staticClass = "v-input--selection-controls__ripple", e.directives = e.directives || [], e.directives.push({
+        name: "ripple",
+        value: {
+          center: !0
+        }
+      }), this.$createElement("div", e)) : null;
+    }
+  }
+});
+function n(e) {
+  e.preventDefault();
+}
+const V = h(l, p, o).extend({
+  name: "selectable",
+  model: {
+    prop: "inputValue",
+    event: "change"
+  },
+  props: {
+    id: String,
+    inputValue: null,
+    falseValue: null,
+    trueValue: null,
+    multiple: {
+      type: Boolean,
+      default: null
+    },
+    label: String
+  },
+  data() {
+    return {
+      hasColor: this.inputValue,
+      lazyValue: this.inputValue
+    };
+  },
+  computed: {
+    computedColor() {
+      if (this.isActive)
+        return this.color ? this.color : this.isDark && !this.appIsDark ? "white" : "primary";
+    },
+    isMultiple() {
+      return this.multiple === !0 || this.multiple === null && Array.isArray(this.internalValue);
+    },
+    isActive() {
+      const e = this.value, t = this.internalValue;
+      return this.isMultiple ? Array.isArray(t) ? t.some((i) => this.valueComparator(i, e)) : !1 : this.trueValue === void 0 || this.falseValue === void 0 ? e ? this.valueComparator(e, t) : !!t : this.valueComparator(t, this.trueValue);
+    },
+    isDirty() {
+      return this.isActive;
+    },
+    rippleState() {
+      return !this.isDisabled && !this.validationState ? void 0 : this.validationState;
+    }
+  },
+  watch: {
+    inputValue(e) {
+      this.lazyValue = e, this.hasColor = e;
+    }
+  },
+  methods: {
+    genLabel() {
+      const e = l.options.methods.genLabel.call(this);
+      return e && (e.data.on = {
+        // Label shouldn't cause the input to focus
+        click: n
+      }, e);
+    },
+    genInput(e, t) {
+      return this.$createElement("input", {
+        attrs: Object.assign({
+          "aria-checked": this.isActive.toString(),
+          disabled: this.isDisabled,
+          id: this.computedId,
+          role: e,
+          type: e
+        }, t),
+        domProps: {
+          value: this.value,
+          checked: this.isActive
+        },
+        on: {
+          blur: this.onBlur,
+          change: this.onChange,
+          focus: this.onFocus,
+          keydown: this.onKeydown,
+          click: n
+        },
+        ref: "input"
+      });
+    },
+    onClick(e) {
+      this.onChange(), this.$emit("click", e);
+    },
+    onChange() {
+      if (!this.isInteractive)
+        return;
+      const e = this.value;
+      let t = this.internalValue;
+      if (this.isMultiple) {
+        Array.isArray(t) || (t = []);
+        const i = t.length;
+        t = t.filter((s) => !this.valueComparator(s, e)), t.length === i && t.push(e);
+      } else
+        this.trueValue !== void 0 && this.falseValue !== void 0 ? t = this.valueComparator(t, this.trueValue) ? this.falseValue : this.trueValue : e ? t = this.valueComparator(t, e) ? null : e : t = !t;
+      this.validate(!0, t), this.internalValue = t, this.hasColor = t;
+    },
+    onFocus(e) {
+      this.isFocused = !0, this.$emit("focus", e);
+    },
+    onBlur(e) {
+      this.isFocused = !1, this.$emit("blur", e);
+    },
+    /** @abstract */
+    onKeydown(e) {
+    }
+  }
+});
+r("css/revolugo.index.CFW4Oklv.css");
+export {
+  p as R,
+  V as S
+};
+//# sourceMappingURL=revolugo.index.tY8MFB9m.min.js.map

package/dist/revolugo.langpicker.yr7wtnZM.min.js

@@ -0,0 +1,103 @@
+import { V as i, k as l } from "./revolugo.i18n.DF3U6VhD.min.js";
+import { m as c, C as u, l as m, n as _ } from "./revolugo.webcomponentwrapper.-wnE6sKX.min.js";
+import { R as d, M as h } from "./revolugo.vsheet.C1tyLBBd.min.js";
+import { h as o } from "./revolugo.revolugo-config.Bs_HF2Eu.min.js";
+import { _ as p, a as f } from "./revolugo.vlistitem.CrJxrMpP.min.js";
+import { _ as g, a as E } from "./revolugo.vtoolbar.D3HhuFrj.min.js";
+function a(s) {
+  try {
+    if (typeof document < "u") {
+      window.REVOLUGO_ELEMENTS_STYLES = window.REVOLUGO_ELEMENTS_STYLES || {
+        sheets: [],
+        components: []
+      };
+      const t = import.meta.url, n = t.slice(0, t.lastIndexOf("/") + 1) + s;
+      window.REVOLUGO_ELEMENTS_STYLES.sheets.push(n);
+      for (const e of REVOLUGO_ELEMENTS_STYLES.components)
+        e(n);
+      if (s.indexOf("fonts") >= 0) {
+        const e = document.createElement("link");
+        e.rel = "stylesheet", linK.href = n, document.head.appendChild(e);
+      }
+    }
+  } catch (t) {
+    console.error("[revolugo-elements] ", t);
+  }
+}
+const L = c(u, h, d).extend({
+  name: "v-avatar",
+  props: {
+    left: Boolean,
+    right: Boolean,
+    size: {
+      type: [Number, String],
+      default: 48
+    }
+  },
+  computed: {
+    classes() {
+      return {
+        "v-avatar--left": this.left,
+        "v-avatar--right": this.right,
+        ...this.roundedClasses
+      };
+    },
+    styles() {
+      return {
+        height: o(this.size),
+        minWidth: o(this.size),
+        width: o(this.size),
+        ...this.measurableStyles
+      };
+    }
+  },
+  render(s) {
+    const t = {
+      staticClass: "v-avatar",
+      class: this.classes,
+      style: this.styles,
+      on: this.$listeners
+    };
+    return s("div", this.setBackgroundColor(this.color, t), this.$slots.default);
+  }
+}), v = i.extend({
+  name: "LangPicker",
+  mixins: [m("components/RevolugoElements/LangPicker")],
+  computed: {
+    locales() {
+      return l;
+    }
+  },
+  methods: {
+    onItemClick(s) {
+      this.updateLang(s);
+    }
+  }
+});
+var C = function() {
+  var t = this, n = t._self._c;
+  return t._self._setupProxy, n(p, [n(g, { attrs: { color: "white", elevation: "0" } }, [n("h4", { staticClass: "grey--text text--darken-2" }, [t._v(" " + t._s(t.$t("LangPicker.title")) + " ")]), t._t("toolbar-right")], 2), t._l(Object.values(t.locales), function(e) {
+    return n(f, { key: e.name, class: t.config.lang === e.code ? "grey lighten-4" : null, attrs: { link: "" }, on: { click: function(r) {
+      return t.onItemClick(e.code);
+    } } }, [n(L, [n(E, { attrs: { "max-height": "34", "max-width": "34", src: `https://flagcdn.com/h60/${e.countryCode.toLowerCase()}.png`, srcset: `https://flagcdn.com/h80/${e.countryCode.toLowerCase()}.png 2x,
+              https://flagcdn.com/h120/${e.countryCode.toLowerCase()}.png 3x` }, on: { click: function(r) {
+      r.stopPropagation(), t.dialog = !0;
+    } } })], 1), n("span", { class: t.config.lang === e.code ? "font-weight-bold" : "" }, [t._v(" " + t._s(e.name) + " ")])], 1);
+  })], 2);
+}, y = [], S = /* @__PURE__ */ _(
+  v,
+  C,
+  y,
+  !1,
+  null,
+  null,
+  null,
+  null
+);
+const b = S.exports;
+a("css/revolugo.langpicker.B3TsOwUq.css");
+export {
+  b as L,
+  L as _
+};
+//# sourceMappingURL=revolugo.langpicker.yr7wtnZM.min.js.map

package/dist/revolugo.langpickerbtn.4XN3tTRs.min.js

@@ -0,0 +1,28 @@
+import { V as r } from "./revolugo.i18n.DF3U6VhD.min.js";
+import { L as o, l as t } from "./revolugo.langpickerbtn.BHhYWwCD.min.js";
+import { W as a, n as s } from "./revolugo.webcomponentwrapper.-wnE6sKX.min.js";
+const p = r.extend({
+  components: {
+    LangPickerBtn: o,
+    WebComponentWrapper: a
+  },
+  props: t
+});
+var c = function() {
+  var n = this, e = n._self._c;
+  return n._self._setupProxy, e("web-component-wrapper", [e("lang-picker-btn", n._b({}, "lang-picker-btn", n.$props, !1))], 1);
+}, l = [], _ = /* @__PURE__ */ s(
+  p,
+  c,
+  l,
+  !1,
+  null,
+  null,
+  null,
+  null
+);
+const g = _.exports;
+export {
+  g as default
+};
+//# sourceMappingURL=revolugo.langpickerbtn.4XN3tTRs.min.js.map