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

package/dist/revolugo.vinput.DFfd_YGp.min.js

@@ -0,0 +1,509 @@
+import { i as S, _ as y } from "./revolugo.index.CnslRErc.min.js";
+import { m as o, T as u, c as g, e as E, C as d } from "./revolugo.webcomponentwrapper.CwAC855u.min.js";
+import { h, j as f, d as M, p as $, B as p } from "./revolugo.revolugo-config.B9n_CElG.min.js";
+import { B as C } from "./revolugo.index.mq4mKuqN.min.js";
+function b(e) {
+  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) + e;
+      window.REVOLUGO_ELEMENTS_STYLES.sheets.push(n);
+      for (const s of REVOLUGO_ELEMENTS_STYLES.components)
+        s(n);
+      if (e.indexOf("fonts") >= 0) {
+        const s = document.createElement("link");
+        s.rel = "stylesheet", linK.href = n, document.head.appendChild(s);
+      }
+    }
+  } catch (t) {
+    console.error("[revolugo-elements] ", t);
+  }
+}
+const D = o(u).extend({
+  name: "v-label",
+  functional: !0,
+  props: {
+    absolute: Boolean,
+    color: {
+      type: String,
+      default: "primary"
+    },
+    disabled: Boolean,
+    focused: Boolean,
+    for: String,
+    left: {
+      type: [Number, String],
+      default: 0
+    },
+    right: {
+      type: [Number, String],
+      default: "auto"
+    },
+    value: Boolean
+  },
+  render(e, t) {
+    const {
+      children: n,
+      listeners: s,
+      props: i,
+      data: r
+    } = t, l = g({
+      staticClass: "v-label",
+      class: {
+        "v-label--active": i.value,
+        "v-label--is-disabled": i.disabled,
+        ...E(t)
+      },
+      attrs: {
+        for: i.for,
+        "aria-hidden": !i.for
+      },
+      on: s,
+      style: {
+        left: h(i.left),
+        right: h(i.right),
+        position: i.absolute ? "absolute" : "relative"
+      },
+      ref: "label"
+    }, r);
+    return e("label", d.options.methods.setTextColor(i.focused && i.color, l), n);
+  }
+}), _ = o(d, u).extend({
+  name: "v-messages",
+  props: {
+    value: {
+      type: Array,
+      default: () => []
+    }
+  },
+  methods: {
+    genChildren() {
+      return this.$createElement("transition-group", {
+        staticClass: "v-messages__wrapper",
+        attrs: {
+          name: "message-transition",
+          tag: "div"
+        }
+      }, this.value.map(this.genMessage));
+    },
+    genMessage(e, t) {
+      return this.$createElement("div", {
+        staticClass: "v-messages__message",
+        key: t
+      }, f(this, "default", {
+        message: e,
+        key: t
+      }) || [e]);
+    }
+  },
+  render(e) {
+    return e("div", this.setTextColor(this.color, {
+      staticClass: "v-messages",
+      class: this.themeClasses
+    }), [this.genChildren()]);
+  }
+}), V = o(d, S("form"), u), B = V.extend({
+  name: "validatable",
+  props: {
+    disabled: {
+      type: Boolean,
+      default: null
+    },
+    error: Boolean,
+    errorCount: {
+      type: [Number, String],
+      default: 1
+    },
+    errorMessages: {
+      type: [String, Array],
+      default: () => []
+    },
+    messages: {
+      type: [String, Array],
+      default: () => []
+    },
+    readonly: {
+      type: Boolean,
+      default: null
+    },
+    rules: {
+      type: Array,
+      default: () => []
+    },
+    success: Boolean,
+    successMessages: {
+      type: [String, Array],
+      default: () => []
+    },
+    validateOnBlur: Boolean,
+    value: {
+      required: !1
+    }
+  },
+  data() {
+    return {
+      errorBucket: [],
+      hasColor: !1,
+      hasFocused: !1,
+      hasInput: !1,
+      isFocused: !1,
+      isResetting: !1,
+      lazyValue: this.value,
+      valid: !1
+    };
+  },
+  computed: {
+    computedColor() {
+      if (!this.isDisabled)
+        return this.color ? this.color : this.isDark && !this.appIsDark ? "white" : "primary";
+    },
+    hasError() {
+      return this.internalErrorMessages.length > 0 || this.errorBucket.length > 0 || this.error;
+    },
+    // TODO: Add logic that allows the user to enable based
+    // upon a good validation
+    hasSuccess() {
+      return this.internalSuccessMessages.length > 0 || this.success;
+    },
+    externalError() {
+      return this.internalErrorMessages.length > 0 || this.error;
+    },
+    hasMessages() {
+      return this.validationTarget.length > 0;
+    },
+    hasState() {
+      return this.isDisabled ? !1 : this.hasSuccess || this.shouldValidate && this.hasError;
+    },
+    internalErrorMessages() {
+      return this.genInternalMessages(this.errorMessages);
+    },
+    internalMessages() {
+      return this.genInternalMessages(this.messages);
+    },
+    internalSuccessMessages() {
+      return this.genInternalMessages(this.successMessages);
+    },
+    internalValue: {
+      get() {
+        return this.lazyValue;
+      },
+      set(e) {
+        this.lazyValue = e, this.$emit("input", e);
+      }
+    },
+    isDisabled() {
+      var e;
+      return (e = this.disabled) !== null && e !== void 0 ? e : !!this.form && this.form.disabled;
+    },
+    isInteractive() {
+      return !this.isDisabled && !this.isReadonly;
+    },
+    isReadonly() {
+      var e;
+      return (e = this.readonly) !== null && e !== void 0 ? e : !!this.form && this.form.readonly;
+    },
+    shouldValidate() {
+      return this.externalError ? !0 : this.isResetting ? !1 : this.validateOnBlur ? this.hasFocused && !this.isFocused : this.hasInput || this.hasFocused;
+    },
+    validations() {
+      return this.validationTarget.slice(0, Number(this.errorCount));
+    },
+    validationState() {
+      if (!this.isDisabled) {
+        if (this.hasError && this.shouldValidate)
+          return "error";
+        if (this.hasSuccess)
+          return "success";
+        if (this.hasColor)
+          return this.computedColor;
+      }
+    },
+    validationTarget() {
+      return this.internalErrorMessages.length > 0 ? this.internalErrorMessages : this.successMessages && this.successMessages.length > 0 ? this.internalSuccessMessages : this.messages && this.messages.length > 0 ? this.internalMessages : this.shouldValidate ? this.errorBucket : [];
+    }
+  },
+  watch: {
+    rules: {
+      handler(e, t) {
+        M(e, t) || this.validate();
+      },
+      deep: !0
+    },
+    internalValue() {
+      this.hasInput = !0, this.validateOnBlur || this.$nextTick(this.validate);
+    },
+    isFocused(e) {
+      !e && !this.isDisabled && (this.hasFocused = !0, this.validateOnBlur && this.$nextTick(this.validate));
+    },
+    isResetting() {
+      setTimeout(() => {
+        this.hasInput = !1, this.hasFocused = !1, this.isResetting = !1, this.validate();
+      }, 0);
+    },
+    hasError(e) {
+      this.shouldValidate && this.$emit("update:error", e);
+    },
+    value(e) {
+      this.lazyValue = e;
+    }
+  },
+  beforeMount() {
+    this.validate();
+  },
+  created() {
+    this.form && this.form.register(this);
+  },
+  beforeDestroy() {
+    this.form && this.form.unregister(this);
+  },
+  methods: {
+    genInternalMessages(e) {
+      return e ? Array.isArray(e) ? e : [e] : [];
+    },
+    /** @public */
+    reset() {
+      this.isResetting = !0, this.internalValue = Array.isArray(this.internalValue) ? [] : null;
+    },
+    /** @public */
+    resetValidation() {
+      this.isResetting = !0;
+    },
+    /** @public */
+    validate(e = !1, t) {
+      const n = [];
+      t = t || this.internalValue, e && (this.hasInput = this.hasFocused = !0);
+      for (let s = 0; s < this.rules.length; s++) {
+        const i = this.rules[s], r = typeof i == "function" ? i(t) : i;
+        r === !1 || typeof r == "string" ? n.push(r || "") : typeof r != "boolean" && $(`Rules should return a string or boolean, received '${typeof r}' instead`, this);
+      }
+      return this.errorBucket = n, this.valid = n.length === 0, this.valid;
+    }
+  }
+}), k = o(C, B), x = k.extend().extend({
+  name: "v-input",
+  inheritAttrs: !1,
+  props: {
+    appendIcon: String,
+    backgroundColor: {
+      type: String,
+      default: ""
+    },
+    dense: Boolean,
+    height: [Number, String],
+    hideDetails: [Boolean, String],
+    hideSpinButtons: Boolean,
+    hint: String,
+    id: String,
+    label: String,
+    loading: Boolean,
+    persistentHint: Boolean,
+    prependIcon: String,
+    value: null
+  },
+  data() {
+    return {
+      lazyValue: this.value,
+      hasMouseDown: !1
+    };
+  },
+  computed: {
+    classes() {
+      return {
+        "v-input--has-state": this.hasState,
+        "v-input--hide-details": !this.showDetails,
+        "v-input--is-label-active": this.isLabelActive,
+        "v-input--is-dirty": this.isDirty,
+        "v-input--is-disabled": this.isDisabled,
+        "v-input--is-focused": this.isFocused,
+        // <v-switch loading>.loading === '' so we can't just cast to boolean
+        "v-input--is-loading": this.loading !== !1 && this.loading != null,
+        "v-input--is-readonly": this.isReadonly,
+        "v-input--dense": this.dense,
+        "v-input--hide-spin-buttons": this.hideSpinButtons,
+        ...this.themeClasses
+      };
+    },
+    computedId() {
+      return this.id || `input-${this._uid}`;
+    },
+    hasDetails() {
+      return this.messagesToDisplay.length > 0;
+    },
+    hasHint() {
+      return !this.hasMessages && !!this.hint && (this.persistentHint || this.isFocused);
+    },
+    hasLabel() {
+      return !!(this.$slots.label || this.label);
+    },
+    // Proxy for `lazyValue`
+    // This allows an input
+    // to function without
+    // a provided model
+    internalValue: {
+      get() {
+        return this.lazyValue;
+      },
+      set(e) {
+        this.lazyValue = e, this.$emit(this.$_modelEvent, e);
+      }
+    },
+    isDirty() {
+      return !!this.lazyValue;
+    },
+    isLabelActive() {
+      return this.isDirty;
+    },
+    messagesToDisplay() {
+      return this.hasHint ? [this.hint] : this.hasMessages ? this.validations.map((e) => {
+        if (typeof e == "string")
+          return e;
+        const t = e(this.internalValue);
+        return typeof t == "string" ? t : "";
+      }).filter((e) => e !== "") : [];
+    },
+    showDetails() {
+      return this.hideDetails === !1 || this.hideDetails === "auto" && this.hasDetails;
+    }
+  },
+  watch: {
+    value(e) {
+      this.lazyValue = e;
+    }
+  },
+  beforeCreate() {
+    this.$_modelEvent = this.$options.model && this.$options.model.event || "input";
+  },
+  methods: {
+    genContent() {
+      return [this.genPrependSlot(), this.genControl(), this.genAppendSlot()];
+    },
+    genControl() {
+      return this.$createElement("div", {
+        staticClass: "v-input__control",
+        attrs: {
+          title: this.attrs$.title
+        }
+      }, [this.genInputSlot(), this.genMessages()]);
+    },
+    genDefaultSlot() {
+      return [this.genLabel(), this.$slots.default];
+    },
+    genIcon(e, t, n = {}) {
+      var s;
+      const i = this[`${e}Icon`], r = `click:${p(e)}`, l = !!(this.listeners$[r] || t), c = {
+        prepend: "prependAction",
+        prependInner: "prependAction",
+        append: "appendAction",
+        appendOuter: "appendAction",
+        clear: "clear"
+      }[e], m = l && c ? this.$vuetify.lang.t(`$vuetify.input.${c}`, (s = this.label) !== null && s !== void 0 ? s : "") : void 0, v = g({
+        attrs: {
+          "aria-label": m,
+          color: this.validationState,
+          dark: this.dark,
+          disabled: this.isDisabled,
+          light: this.light,
+          tabindex: e === "clear" ? -1 : void 0
+        },
+        on: l ? {
+          click: (a) => {
+            a.preventDefault(), a.stopPropagation(), this.$emit(r, a), t && t(a);
+          },
+          // Container has g event that will
+          // trigger menu open if enclosed
+          mouseup: (a) => {
+            a.preventDefault(), a.stopPropagation();
+          }
+        } : void 0
+      }, n);
+      return this.$createElement("div", {
+        staticClass: "v-input__icon",
+        class: e ? `v-input__icon--${p(e)}` : void 0
+      }, [this.$createElement(y, v, i)]);
+    },
+    genInputSlot() {
+      return this.$createElement("div", this.setBackgroundColor(this.backgroundColor, {
+        staticClass: "v-input__slot",
+        style: {
+          height: h(this.height)
+        },
+        on: {
+          click: this.onClick,
+          mousedown: this.onMouseDown,
+          mouseup: this.onMouseUp
+        },
+        ref: "input-slot"
+      }), [this.genDefaultSlot()]);
+    },
+    genLabel() {
+      return this.hasLabel ? this.$createElement(D, {
+        props: {
+          color: this.validationState,
+          dark: this.dark,
+          disabled: this.isDisabled,
+          focused: this.hasState,
+          for: this.computedId,
+          light: this.light
+        }
+      }, this.$slots.label || this.label) : null;
+    },
+    genMessages() {
+      return this.showDetails ? this.$createElement(_, {
+        props: {
+          color: this.hasHint ? "" : this.validationState,
+          dark: this.dark,
+          light: this.light,
+          value: this.messagesToDisplay
+        },
+        attrs: {
+          role: this.hasMessages ? "alert" : null
+        },
+        scopedSlots: {
+          default: (e) => f(this, "message", e)
+        }
+      }) : null;
+    },
+    genSlot(e, t, n) {
+      if (!n.length)
+        return null;
+      const s = `${e}-${t}`;
+      return this.$createElement("div", {
+        staticClass: `v-input__${s}`,
+        ref: s
+      }, n);
+    },
+    genPrependSlot() {
+      const e = [];
+      return this.$slots.prepend ? e.push(this.$slots.prepend) : this.prependIcon && e.push(this.genIcon("prepend")), this.genSlot("prepend", "outer", e);
+    },
+    genAppendSlot() {
+      const e = [];
+      return this.$slots.append ? e.push(this.$slots.append) : this.appendIcon && e.push(this.genIcon("append")), this.genSlot("append", "outer", e);
+    },
+    onClick(e) {
+      this.$emit("click", e);
+    },
+    onMouseDown(e) {
+      this.hasMouseDown = !0, this.$emit("mousedown", e);
+    },
+    onMouseUp(e) {
+      this.hasMouseDown = !1, this.$emit("mouseup", e);
+    }
+  },
+  render(e) {
+    return e("div", this.setTextColor(this.validationState, {
+      staticClass: "v-input",
+      class: this.classes
+    }), this.genContent());
+  }
+});
+b("css/revolugo.vinput.SfhpXNi0.css");
+export {
+  x as V,
+  B as a,
+  D as b
+};
+//# sourceMappingURL=revolugo.vinput.DFfd_YGp.min.js.map

package/dist/revolugo.vitemgroup.CkDfn6V_.min.js

@@ -0,0 +1,168 @@
+import { C as r } from "./revolugo.index.CVaQfmC0.min.js";
+import { P as l } from "./revolugo.index.Dx0TIvP-.min.js";
+import { m as u, T as h } from "./revolugo.webcomponentwrapper.CwAC855u.min.js";
+import { q as o } from "./revolugo.revolugo-config.B9n_CElG.min.js";
+function a(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 d = u(r, l, h).extend({
+  name: "base-item-group",
+  props: {
+    activeClass: {
+      type: String,
+      default: "v-item--active"
+    },
+    mandatory: Boolean,
+    max: {
+      type: [Number, String],
+      default: null
+    },
+    multiple: Boolean,
+    tag: {
+      type: String,
+      default: "div"
+    }
+  },
+  data() {
+    return {
+      // As long as a value is defined, show it
+      // Otherwise, check if multiple
+      // to determine which default to provide
+      internalLazyValue: this.value !== void 0 ? this.value : this.multiple ? [] : void 0,
+      items: []
+    };
+  },
+  computed: {
+    classes() {
+      return {
+        "v-item-group": !0,
+        ...this.themeClasses
+      };
+    },
+    selectedIndex() {
+      return this.selectedItem && this.items.indexOf(this.selectedItem) || -1;
+    },
+    selectedItem() {
+      if (!this.multiple)
+        return this.selectedItems[0];
+    },
+    selectedItems() {
+      return this.items.filter((e, t) => this.toggleMethod(this.getValue(e, t)));
+    },
+    selectedValues() {
+      return this.internalValue == null ? [] : Array.isArray(this.internalValue) ? this.internalValue : [this.internalValue];
+    },
+    toggleMethod() {
+      if (!this.multiple)
+        return (t) => this.valueComparator(this.internalValue, t);
+      const e = this.internalValue;
+      return Array.isArray(e) ? (t) => e.some((i) => this.valueComparator(i, t)) : () => !1;
+    }
+  },
+  watch: {
+    internalValue: "updateItemsState",
+    items: "updateItemsState"
+  },
+  created() {
+    this.multiple && !Array.isArray(this.internalValue) && o("Model must be bound to an array if the multiple property is true.", this);
+  },
+  methods: {
+    genData() {
+      return {
+        class: this.classes
+      };
+    },
+    getValue(e, t) {
+      return e.value === void 0 ? t : e.value;
+    },
+    onClick(e) {
+      this.updateInternalValue(this.getValue(e, this.items.indexOf(e)));
+    },
+    register(e) {
+      const t = this.items.push(e) - 1;
+      e.$on("change", () => this.onClick(e)), this.mandatory && !this.selectedValues.length && this.updateMandatory(), this.updateItem(e, t);
+    },
+    unregister(e) {
+      if (this._isDestroyed)
+        return;
+      const t = this.items.indexOf(e), i = this.getValue(e, t);
+      if (this.items.splice(t, 1), !(this.selectedValues.indexOf(i) < 0)) {
+        if (!this.mandatory)
+          return this.updateInternalValue(i);
+        this.multiple && Array.isArray(this.internalValue) ? this.internalValue = this.internalValue.filter((n) => n !== i) : this.internalValue = void 0, this.selectedItems.length || this.updateMandatory(!0);
+      }
+    },
+    updateItem(e, t) {
+      const i = this.getValue(e, t);
+      e.isActive = this.toggleMethod(i);
+    },
+    // https://github.com/vuetifyjs/vuetify/issues/5352
+    updateItemsState() {
+      this.$nextTick(() => {
+        if (this.mandatory && !this.selectedItems.length)
+          return this.updateMandatory();
+        this.items.forEach(this.updateItem);
+      });
+    },
+    updateInternalValue(e) {
+      this.multiple ? this.updateMultiple(e) : this.updateSingle(e);
+    },
+    updateMandatory(e) {
+      if (!this.items.length)
+        return;
+      const t = this.items.slice();
+      e && t.reverse();
+      const i = t.find((n) => !n.disabled);
+      if (!i)
+        return;
+      const s = this.items.indexOf(i);
+      this.updateInternalValue(this.getValue(i, s));
+    },
+    updateMultiple(e) {
+      const i = (Array.isArray(this.internalValue) ? this.internalValue : []).slice(), s = i.findIndex((n) => this.valueComparator(n, e));
+      this.mandatory && // Item already exists
+      s > -1 && // value would be reduced below min
+      i.length - 1 < 1 || // Max is set
+      this.max != null && // Item doesn't exist
+      s < 0 && // value would be increased above max
+      i.length + 1 > this.max || (s > -1 ? i.splice(s, 1) : i.push(e), this.internalValue = i);
+    },
+    updateSingle(e) {
+      const t = this.valueComparator(this.internalValue, e);
+      this.mandatory && t || (this.internalValue = t ? void 0 : e);
+    }
+  },
+  render(e) {
+    return e(this.tag, this.genData(), this.$slots.default);
+  }
+});
+d.extend({
+  name: "v-item-group",
+  provide() {
+    return {
+      itemGroup: this
+    };
+  }
+});
+a("css/revolugo.vitemgroup.EbHsz8Rr.css");
+export {
+  d as B
+};
+//# sourceMappingURL=revolugo.vitemgroup.CkDfn6V_.min.js.map