@revolugo/elements 5.5.1 → 5.5.2-beta.0

package/dist/revolugo.termsandconditions.iierLPPe.min.js

@@ -0,0 +1,27 @@
+import { V as e } from "./revolugo.i18n.CyGKqo0B.min.js";
+import { T as r } from "./revolugo.termsandconditions.gfMYAJC9.min.js";
+import { W as s, n as t } from "./revolugo.webcomponentwrapper.C4B-n-nK.min.js";
+const a = e.extend({
+  components: {
+    TermsAndConditions: r,
+    WebComponentWrapper: s
+  }
+});
+var m = function() {
+  var n = this, o = n._self._c;
+  return n._self._setupProxy, o("web-component-wrapper", [o("terms-and-conditions", n._b({}, "terms-and-conditions", n.$props, !1))], 1);
+}, i = [], p = /* @__PURE__ */ t(
+  a,
+  m,
+  i,
+  !1,
+  null,
+  null,
+  null,
+  null
+);
+const f = p.exports;
+export {
+  f as default
+};
+//# sourceMappingURL=revolugo.termsandconditions.iierLPPe.min.js.map

package/dist/revolugo.typed-mixins.D4p2Nb8x.min.js

@@ -0,0 +1,8 @@
+import { V as e } from "./revolugo.i18n.CyGKqo0B.min.js";
+function n(...t) {
+  return e.extend({ mixins: t });
+}
+export {
+  n as t
+};
+//# sourceMappingURL=revolugo.typed-mixins.D4p2Nb8x.min.js.map

package/dist/revolugo.valert.D2QkjVyq.min.js

@@ -0,0 +1,194 @@
+import { _ as r } from "./revolugo.vsheet.g-wezcj4.min.js";
+import { _ as l } from "./revolugo.vbtn.BnwFj80Q.min.js";
+import { _ as i } from "./revolugo.index.FGCgdl6A.min.js";
+import { m as a, b as c, T as h } from "./revolugo.webcomponentwrapper.C4B-n-nK.min.js";
+import { T as d } from "./revolugo.index.DVlgraIx.min.js";
+import { i as u } from "./revolugo.revolugo-config.CV2-KqZg.min.js";
+function n(t) {
+  try {
+    if (typeof document < "u") {
+      window.REVOLUGO_ELEMENTS_STYLES = window.REVOLUGO_ELEMENTS_STYLES || {
+        sheets: [],
+        components: []
+      };
+      const e = import.meta.url, o = e.slice(0, e.lastIndexOf("/") + 1) + t;
+      window.REVOLUGO_ELEMENTS_STYLES.sheets.push(o);
+      for (const s of REVOLUGO_ELEMENTS_STYLES.components)
+        s(o);
+      if (t.indexOf("fonts") >= 0) {
+        const s = document.createElement("link");
+        s.rel = "stylesheet", linK.href = o, document.head.appendChild(s);
+      }
+    }
+  } catch (e) {
+    console.error("[revolugo-elements] ", e);
+  }
+}
+const E = a(r, c, d).extend({
+  name: "v-alert",
+  props: {
+    border: {
+      type: String,
+      validator(t) {
+        return ["top", "right", "bottom", "left"].includes(t);
+      }
+    },
+    closeLabel: {
+      type: String,
+      default: "$vuetify.close"
+    },
+    coloredBorder: Boolean,
+    dense: Boolean,
+    dismissible: Boolean,
+    closeIcon: {
+      type: String,
+      default: "$cancel"
+    },
+    icon: {
+      default: "",
+      type: [Boolean, String],
+      validator(t) {
+        return typeof t == "string" || t === !1;
+      }
+    },
+    outlined: Boolean,
+    prominent: Boolean,
+    text: Boolean,
+    type: {
+      type: String,
+      validator(t) {
+        return ["info", "error", "success", "warning"].includes(t);
+      }
+    },
+    value: {
+      type: Boolean,
+      default: !0
+    }
+  },
+  computed: {
+    __cachedBorder() {
+      if (!this.border)
+        return null;
+      let t = {
+        staticClass: "v-alert__border",
+        class: {
+          [`v-alert__border--${this.border}`]: !0
+        }
+      };
+      return this.coloredBorder && (t = this.setBackgroundColor(this.computedColor, t), t.class["v-alert__border--has-color"] = !0), this.$createElement("div", t);
+    },
+    __cachedDismissible() {
+      if (!this.dismissible)
+        return null;
+      const t = this.iconColor;
+      return this.$createElement(l, {
+        staticClass: "v-alert__dismissible",
+        props: {
+          color: t,
+          icon: !0,
+          small: !0
+        },
+        attrs: {
+          "aria-label": this.$vuetify.lang.t(this.closeLabel)
+        },
+        on: {
+          click: () => this.isActive = !1
+        }
+      }, [this.$createElement(i, {
+        props: {
+          color: t
+        }
+      }, this.closeIcon)]);
+    },
+    __cachedIcon() {
+      return this.computedIcon ? this.$createElement(i, {
+        staticClass: "v-alert__icon",
+        props: {
+          color: this.iconColor
+        }
+      }, this.computedIcon) : null;
+    },
+    classes() {
+      const t = {
+        ...r.options.computed.classes.call(this),
+        "v-alert--border": !!this.border,
+        "v-alert--dense": this.dense,
+        "v-alert--outlined": this.outlined,
+        "v-alert--prominent": this.prominent,
+        "v-alert--text": this.text
+      };
+      return this.border && (t[`v-alert--border-${this.border}`] = !0), t;
+    },
+    computedColor() {
+      return this.color || this.type;
+    },
+    computedIcon() {
+      return this.icon === !1 ? !1 : typeof this.icon == "string" && this.icon ? this.icon : ["error", "info", "success", "warning"].includes(this.type) ? `$${this.type}` : !1;
+    },
+    hasColoredIcon() {
+      return this.hasText || !!this.border && this.coloredBorder;
+    },
+    hasText() {
+      return this.text || this.outlined;
+    },
+    iconColor() {
+      return this.hasColoredIcon ? this.computedColor : void 0;
+    },
+    isDark() {
+      return this.type && !this.coloredBorder && !this.outlined ? !0 : h.options.computed.isDark.call(this);
+    }
+  },
+  created() {
+    this.$attrs.hasOwnProperty("outline") && u("outline", "outlined", this);
+  },
+  methods: {
+    genWrapper() {
+      const t = [this.$slots.prepend || this.__cachedIcon, this.genContent(), this.__cachedBorder, this.$slots.append, this.$scopedSlots.close ? this.$scopedSlots.close({
+        toggle: this.toggle
+      }) : this.__cachedDismissible], e = {
+        staticClass: "v-alert__wrapper"
+      };
+      return this.$createElement("div", e, t);
+    },
+    genContent() {
+      return this.$createElement("div", {
+        staticClass: "v-alert__content"
+      }, this.$slots.default);
+    },
+    genAlert() {
+      let t = {
+        staticClass: "v-alert",
+        attrs: {
+          role: "alert"
+        },
+        on: this.listeners$,
+        class: this.classes,
+        style: this.styles,
+        directives: [{
+          name: "show",
+          value: this.isActive
+        }]
+      };
+      return this.coloredBorder || (t = (this.hasText ? this.setTextColor : this.setBackgroundColor)(this.computedColor, t)), this.$createElement("div", t, [this.genWrapper()]);
+    },
+    /** @public */
+    toggle() {
+      this.isActive = !this.isActive;
+    }
+  },
+  render(t) {
+    const e = this.genAlert();
+    return this.transition ? t("transition", {
+      props: {
+        name: this.transition,
+        origin: this.origin,
+        mode: this.mode
+      }
+    }, [e]) : e;
+  }
+});
+n("css/revolugo.valert.BzcMswjJ.css");
+export {
+  E as _
+};
+//# sourceMappingURL=revolugo.valert.D2QkjVyq.min.js.map

package/dist/revolugo.vautocomplete.DesK4IqD.min.js

@@ -0,0 +1,255 @@
+import { _ as i, d as c } from "./revolugo.vselect.DGAcOur7.min.js";
+import { _ as u } from "./revolugo.vtextfield.Bz_46CYU.min.js";
+import { c as d } from "./revolugo.webcomponentwrapper.C4B-n-nK.min.js";
+import { s as m, k as l, t as a } from "./revolugo.revolugo-config.CV2-KqZg.min.js";
+function o(e) {
+  try {
+    if (typeof document < "u") {
+      window.REVOLUGO_ELEMENTS_STYLES = window.REVOLUGO_ELEMENTS_STYLES || {
+        sheets: [],
+        components: []
+      };
+      const t = import.meta.url, s = t.slice(0, t.lastIndexOf("/") + 1) + e;
+      window.REVOLUGO_ELEMENTS_STYLES.sheets.push(s);
+      for (const n of REVOLUGO_ELEMENTS_STYLES.components)
+        n(s);
+      if (e.indexOf("fonts") >= 0) {
+        const n = document.createElement("link");
+        n.rel = "stylesheet", linK.href = s, document.head.appendChild(n);
+      }
+    }
+  } catch (t) {
+    console.error("[revolugo-elements] ", t);
+  }
+}
+const h = {
+  ...c,
+  offsetY: !0,
+  offsetOverflow: !0,
+  transition: !1
+}, x = i.extend({
+  name: "v-autocomplete",
+  props: {
+    autoSelectFirst: {
+      type: Boolean,
+      default: !1
+    },
+    filter: {
+      type: Function,
+      default: (e, t, s) => s.toLocaleLowerCase().indexOf(t.toLocaleLowerCase()) > -1
+    },
+    hideNoData: Boolean,
+    menuProps: {
+      type: i.options.props.menuProps.type,
+      default: () => h
+    },
+    noFilter: Boolean,
+    searchInput: {
+      type: String
+    }
+  },
+  data() {
+    return {
+      lazySearch: this.searchInput
+    };
+  },
+  computed: {
+    classes() {
+      return {
+        ...i.options.computed.classes.call(this),
+        "v-autocomplete": !0,
+        "v-autocomplete--is-selecting-index": this.selectedIndex > -1
+      };
+    },
+    computedItems() {
+      return this.filteredItems;
+    },
+    selectedValues() {
+      return this.selectedItems.map((e) => this.getValue(e));
+    },
+    hasDisplayedItems() {
+      return this.hideSelected ? this.filteredItems.some((e) => !this.hasItem(e)) : this.filteredItems.length > 0;
+    },
+    currentRange() {
+      return this.selectedItem == null ? 0 : String(this.getText(this.selectedItem)).length;
+    },
+    filteredItems() {
+      return !this.isSearching || this.noFilter || this.internalSearch == null ? this.allItems : this.allItems.filter((e) => {
+        const t = m(e, this.itemText), s = t != null ? String(t) : "";
+        return this.filter(e, String(this.internalSearch), s);
+      });
+    },
+    internalSearch: {
+      get() {
+        return this.lazySearch;
+      },
+      set(e) {
+        this.lazySearch !== e && (this.lazySearch = e, this.$emit("update:search-input", e));
+      }
+    },
+    isAnyValueAllowed() {
+      return !1;
+    },
+    isDirty() {
+      return this.searchIsDirty || this.selectedItems.length > 0;
+    },
+    isSearching() {
+      return this.multiple && this.searchIsDirty || this.searchIsDirty && this.internalSearch !== this.getText(this.selectedItem);
+    },
+    menuCanShow() {
+      return this.isFocused ? this.hasDisplayedItems || !this.hideNoData : !1;
+    },
+    $_menuProps() {
+      const e = i.options.computed.$_menuProps.call(this);
+      return e.contentClass = `v-autocomplete__content ${e.contentClass || ""}`.trim(), {
+        ...h,
+        ...e
+      };
+    },
+    searchIsDirty() {
+      return this.internalSearch != null && this.internalSearch !== "";
+    },
+    selectedItem() {
+      return this.multiple ? null : this.selectedItems.find((e) => this.valueComparator(this.getValue(e), this.getValue(this.internalValue)));
+    },
+    listData() {
+      const e = i.options.computed.listData.call(this);
+      return e.props = {
+        ...e.props,
+        items: this.virtualizedItems,
+        noFilter: this.noFilter || !this.isSearching || !this.filteredItems.length,
+        searchInput: this.internalSearch
+      }, e;
+    }
+  },
+  watch: {
+    filteredItems: "onFilteredItemsChanged",
+    internalValue: "setSearch",
+    isFocused(e) {
+      e ? (document.addEventListener("copy", this.onCopy), this.$refs.input && this.$refs.input.select()) : (document.removeEventListener("copy", this.onCopy), this.blur(), this.updateSelf());
+    },
+    isMenuActive(e) {
+      e || !this.hasSlot || (this.lazySearch = null);
+    },
+    items(e, t) {
+      !(t && t.length) && this.hideNoData && this.isFocused && !this.isMenuActive && e.length && this.activateMenu();
+    },
+    searchInput(e) {
+      this.lazySearch = e;
+    },
+    internalSearch: "onInternalSearchChanged",
+    itemText: "updateSelf"
+  },
+  created() {
+    this.setSearch();
+  },
+  destroyed() {
+    document.removeEventListener("copy", this.onCopy);
+  },
+  methods: {
+    onFilteredItemsChanged(e, t) {
+      if (e !== t) {
+        if (!this.autoSelectFirst) {
+          const s = t[this.$refs.menu.listIndex];
+          s ? this.setMenuIndex(e.findIndex((n) => n === s)) : this.setMenuIndex(-1), this.$emit("update:list-index", this.$refs.menu.listIndex);
+        }
+        this.$nextTick(() => {
+          !this.internalSearch || e.length !== 1 && !this.autoSelectFirst || (this.$refs.menu.getTiles(), this.autoSelectFirst && e.length && (this.setMenuIndex(0), this.$emit("update:list-index", this.$refs.menu.listIndex)));
+        });
+      }
+    },
+    onInternalSearchChanged() {
+      this.updateMenuDimensions();
+    },
+    updateMenuDimensions() {
+      this.isMenuActive && this.$refs.menu && this.$refs.menu.updateDimensions();
+    },
+    changeSelectedIndex(e) {
+      this.searchIsDirty || (this.multiple && e === l.left ? this.selectedIndex === -1 ? this.selectedIndex = this.selectedItems.length - 1 : this.selectedIndex-- : this.multiple && e === l.right ? this.selectedIndex >= this.selectedItems.length - 1 ? this.selectedIndex = -1 : this.selectedIndex++ : (e === l.backspace || e === l.delete) && this.deleteCurrentItem());
+    },
+    deleteCurrentItem() {
+      const e = this.selectedIndex, t = this.selectedItems[e];
+      if (!this.isInteractive || this.getDisabled(t))
+        return;
+      const s = this.selectedItems.length - 1;
+      if (this.selectedIndex === -1 && s !== 0) {
+        this.selectedIndex = s;
+        return;
+      }
+      const n = this.selectedItems.length, r = e !== n - 1 ? e : e - 1;
+      this.selectedItems[r] ? this.selectItem(t) : this.setValue(this.multiple ? [] : null), this.selectedIndex = r;
+    },
+    clearableCallback() {
+      this.internalSearch = null, i.options.methods.clearableCallback.call(this);
+    },
+    genInput() {
+      const e = u.options.methods.genInput.call(this);
+      return e.data = d(e.data, {
+        attrs: {
+          "aria-activedescendant": a(this.$refs.menu, "activeTile.id"),
+          autocomplete: a(e.data, "attrs.autocomplete", "off")
+        },
+        domProps: {
+          value: this.internalSearch
+        }
+      }), e;
+    },
+    genInputSlot() {
+      const e = i.options.methods.genInputSlot.call(this);
+      return e.data.attrs.role = "combobox", e;
+    },
+    genSelections() {
+      return this.hasSlot || this.multiple ? i.options.methods.genSelections.call(this) : [];
+    },
+    onClick(e) {
+      this.isInteractive && (this.selectedIndex > -1 ? this.selectedIndex = -1 : this.onFocus(), this.isAppendInner(e.target) || this.activateMenu());
+    },
+    onInput(e) {
+      if (this.selectedIndex > -1 || !e.target)
+        return;
+      const t = e.target, s = t.value;
+      t.value && this.activateMenu(), !this.multiple && s === "" && this.deleteCurrentItem(), this.internalSearch = s, this.badInput = t.validity && t.validity.badInput;
+    },
+    onKeyDown(e) {
+      const t = e.keyCode;
+      (e.ctrlKey || ![l.home, l.end].includes(t)) && i.options.methods.onKeyDown.call(this, e), this.changeSelectedIndex(t);
+    },
+    onSpaceDown(e) {
+    },
+    onTabDown(e) {
+      i.options.methods.onTabDown.call(this, e), this.updateSelf();
+    },
+    onUpDown(e) {
+      e.preventDefault(), this.activateMenu();
+    },
+    selectItem(e) {
+      i.options.methods.selectItem.call(this, e), this.setSearch();
+    },
+    setSelectedItems() {
+      i.options.methods.setSelectedItems.call(this), this.isFocused || this.setSearch();
+    },
+    setSearch() {
+      this.$nextTick(() => {
+        (!this.multiple || !this.internalSearch || !this.isMenuActive) && (this.internalSearch = !this.selectedItems.length || this.multiple || this.hasSlot ? null : this.getText(this.selectedItem));
+      });
+    },
+    updateSelf() {
+      !this.searchIsDirty && !this.internalValue || !this.multiple && !this.valueComparator(this.internalSearch, this.getValue(this.internalValue)) && this.setSearch();
+    },
+    hasItem(e) {
+      return this.selectedValues.indexOf(this.getValue(e)) > -1;
+    },
+    onCopy(e) {
+      var t, s;
+      if (this.selectedIndex === -1)
+        return;
+      const n = this.selectedItems[this.selectedIndex], r = this.getText(n);
+      (t = e.clipboardData) === null || t === void 0 || t.setData("text/plain", r), (s = e.clipboardData) === null || s === void 0 || s.setData("text/vnd.vuetify.autocomplete.item+plain", r), e.preventDefault();
+    }
+  }
+});
+o("css/revolugo.vautocomplete.OMX_yAge.css");
+export {
+  x as _
+};
+//# sourceMappingURL=revolugo.vautocomplete.DesK4IqD.min.js.map

package/dist/revolugo.vbadge.D8uLY_qO.min.js

@@ -0,0 +1,172 @@
+import { _ as a } from "./revolugo.index.FGCgdl6A.min.js";
+import { m as l, b as h, T as d, C as c } from "./revolugo.webcomponentwrapper.C4B-n-nK.min.js";
+import { T as u } from "./revolugo.index.DVlgraIx.min.js";
+import { f } from "./revolugo.index.2rRqbmTI.min.js";
+import { h as m, j as o } from "./revolugo.revolugo-config.CV2-KqZg.min.js";
+function r(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 T = l(c, f(["left", "bottom"]), d, h, u).extend({
+  name: "v-badge",
+  props: {
+    avatar: Boolean,
+    bordered: Boolean,
+    color: {
+      type: String,
+      default: "primary"
+    },
+    content: {
+      required: !1
+    },
+    dot: Boolean,
+    label: {
+      type: String,
+      default: "$vuetify.badge"
+    },
+    icon: String,
+    inline: Boolean,
+    offsetX: [Number, String],
+    offsetY: [Number, String],
+    overlap: Boolean,
+    tile: Boolean,
+    transition: {
+      type: String,
+      default: "scale-rotate-transition"
+    },
+    value: {
+      default: !0
+    }
+  },
+  computed: {
+    classes() {
+      return {
+        "v-badge--avatar": this.avatar,
+        "v-badge--bordered": this.bordered,
+        "v-badge--bottom": this.bottom,
+        "v-badge--dot": this.dot,
+        "v-badge--icon": this.icon != null,
+        "v-badge--inline": this.inline,
+        "v-badge--left": this.left,
+        "v-badge--overlap": this.overlap,
+        "v-badge--tile": this.tile,
+        ...this.themeClasses
+      };
+    },
+    computedBottom() {
+      return this.bottom ? "auto" : this.computedYOffset;
+    },
+    computedLeft() {
+      return this.isRtl ? this.left ? this.computedXOffset : "auto" : this.left ? "auto" : this.computedXOffset;
+    },
+    computedRight() {
+      return this.isRtl ? this.left ? "auto" : this.computedXOffset : this.left ? this.computedXOffset : "auto";
+    },
+    computedTop() {
+      return this.bottom ? this.computedYOffset : "auto";
+    },
+    computedXOffset() {
+      return this.calcPosition(this.offsetX);
+    },
+    computedYOffset() {
+      return this.calcPosition(this.offsetY);
+    },
+    isRtl() {
+      return this.$vuetify.rtl;
+    },
+    // Default fallback if offsetX
+    // or offsetY are undefined.
+    offset() {
+      return this.overlap ? this.dot ? 8 : 12 : this.dot ? 2 : 4;
+    },
+    styles() {
+      return this.inline ? {} : {
+        bottom: this.computedBottom,
+        left: this.computedLeft,
+        right: this.computedRight,
+        top: this.computedTop
+      };
+    }
+  },
+  methods: {
+    calcPosition(t) {
+      return `calc(100% - ${m(t || this.offset)})`;
+    },
+    genBadge() {
+      const t = this.$vuetify.lang, e = this.$attrs["aria-label"] || t.t(this.label), i = this.setBackgroundColor(this.color, {
+        staticClass: "v-badge__badge",
+        style: this.styles,
+        attrs: {
+          "aria-atomic": this.$attrs["aria-atomic"] || "true",
+          "aria-label": e,
+          "aria-live": this.$attrs["aria-live"] || "polite",
+          title: this.$attrs.title,
+          role: this.$attrs.role || "status"
+        },
+        directives: [{
+          name: "show",
+          value: this.isActive
+        }]
+      }), s = this.$createElement("span", i, [this.genBadgeContent()]);
+      return this.transition ? this.$createElement("transition", {
+        props: {
+          name: this.transition,
+          origin: this.origin,
+          mode: this.mode
+        }
+      }, [s]) : s;
+    },
+    genBadgeContent() {
+      if (this.dot)
+        return;
+      const t = o(this, "badge");
+      if (t)
+        return t;
+      if (this.content)
+        return String(this.content);
+      if (this.icon)
+        return this.$createElement(a, this.icon);
+    },
+    genBadgeWrapper() {
+      return this.$createElement("span", {
+        staticClass: "v-badge__wrapper"
+      }, [this.genBadge()]);
+    }
+  },
+  render(t) {
+    const e = [this.genBadgeWrapper()], i = [o(this)], {
+      "aria-atomic": s,
+      "aria-label": p,
+      "aria-live": g,
+      role: b,
+      title: v,
+      ...n
+    } = this.$attrs;
+    return this.inline && this.left ? i.unshift(e) : i.push(e), t("span", {
+      staticClass: "v-badge",
+      attrs: n,
+      class: this.classes
+    }, i);
+  }
+});
+r("css/revolugo.vbadge.CiK_DSkI.css");
+export {
+  T as _
+};
+//# sourceMappingURL=revolugo.vbadge.D8uLY_qO.min.js.map