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

package/dist/revolugo.vsnackbar.BNgumj3w.min.js

@@ -0,0 +1,178 @@
+import { _ as n } from "./revolugo.vsheet.Cqbr0KfV.min.js";
+import { m as u, b as m, C as p, T as d } from "./revolugo.webcomponentwrapper.CwAC855u.min.js";
+import { f as v } from "./revolugo.index.mq4mKuqN.min.js";
+import { h as o, m as g, n as f, j as a } from "./revolugo.revolugo-config.B9n_CElG.min.js";
+function h(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 b = u(
+  n,
+  p,
+  m,
+  v(["absolute", "bottom", "left", "right", "top"])
+  /* @vue/component */
+).extend({
+  name: "v-snackbar",
+  props: {
+    app: Boolean,
+    centered: Boolean,
+    contentClass: {
+      type: String,
+      default: ""
+    },
+    multiLine: Boolean,
+    text: Boolean,
+    timeout: {
+      type: [Number, String],
+      default: 5e3
+    },
+    transition: {
+      type: [Boolean, String],
+      default: "v-snack-transition",
+      validator: (t) => typeof t == "string" || t === !1
+    },
+    vertical: Boolean
+  },
+  data: () => ({
+    activeTimeout: -1
+  }),
+  computed: {
+    classes() {
+      return {
+        "v-snack--absolute": this.absolute,
+        "v-snack--active": this.isActive,
+        "v-snack--bottom": this.bottom || !this.top,
+        "v-snack--centered": this.centered,
+        "v-snack--has-background": this.hasBackground,
+        "v-snack--left": this.left,
+        "v-snack--multi-line": this.multiLine && !this.vertical,
+        "v-snack--right": this.right,
+        "v-snack--text": this.text,
+        "v-snack--top": this.top,
+        "v-snack--vertical": this.vertical
+      };
+    },
+    // Text and outlined styles both
+    // use transparent backgrounds
+    hasBackground() {
+      return !this.text && !this.outlined;
+    },
+    // Snackbar is dark by default
+    // override themeable logic.
+    isDark() {
+      return this.hasBackground ? !this.light : d.options.computed.isDark.call(this);
+    },
+    styles() {
+      if (this.absolute || !this.app)
+        return {};
+      const {
+        bar: t,
+        bottom: e,
+        footer: i,
+        insetFooter: s,
+        left: r,
+        right: c,
+        top: l
+      } = this.$vuetify.application;
+      return {
+        paddingBottom: o(e + i + s),
+        paddingLeft: o(r),
+        paddingRight: o(c),
+        paddingTop: o(t + l)
+      };
+    }
+  },
+  watch: {
+    isActive: "setTimeout",
+    timeout: "setTimeout"
+  },
+  mounted() {
+    this.isActive && this.setTimeout();
+  },
+  created() {
+    this.$attrs.hasOwnProperty("auto-height") && g("auto-height", this), this.timeout == 0 && f('timeout="0"', "-1", this);
+  },
+  methods: {
+    genActions() {
+      return this.$createElement("div", {
+        staticClass: "v-snack__action "
+      }, [a(this, "action", {
+        attrs: {
+          class: "v-snack__btn"
+        }
+      })]);
+    },
+    genContent() {
+      return this.$createElement("div", {
+        staticClass: "v-snack__content",
+        class: {
+          [this.contentClass]: !0
+        },
+        attrs: {
+          role: "status",
+          "aria-live": "polite"
+        }
+      }, [a(this)]);
+    },
+    genWrapper() {
+      const e = (this.hasBackground ? this.setBackgroundColor : this.setTextColor)(this.color, {
+        staticClass: "v-snack__wrapper",
+        class: n.options.computed.classes.call(this),
+        style: n.options.computed.styles.call(this),
+        directives: [{
+          name: "show",
+          value: this.isActive
+        }],
+        on: {
+          pointerenter: () => window.clearTimeout(this.activeTimeout),
+          pointerleave: this.setTimeout
+        }
+      });
+      return this.$createElement("div", e, [this.genContent(), this.genActions()]);
+    },
+    genTransition() {
+      return this.$createElement("transition", {
+        props: {
+          name: this.transition
+        }
+      }, [this.genWrapper()]);
+    },
+    setTimeout() {
+      window.clearTimeout(this.activeTimeout);
+      const t = Number(this.timeout);
+      !this.isActive || // TODO: remove 0 in v3
+      [0, -1].includes(t) || (this.activeTimeout = window.setTimeout(() => {
+        this.isActive = !1;
+      }, t));
+    }
+  },
+  render(t) {
+    return t("div", {
+      staticClass: "v-snack",
+      class: this.classes,
+      style: this.styles
+    }, [this.transition !== !1 ? this.genTransition() : this.genWrapper()]);
+  }
+});
+h("css/revolugo.vsnackbar.DTAXPYkr.css");
+export {
+  b as _
+};
+//# sourceMappingURL=revolugo.vsnackbar.BNgumj3w.min.js.map

package/dist/revolugo.vtextfield.C9nZE6f1.min.js

@@ -0,0 +1,438 @@
+import { V as l, a as p, b as m } from "./revolugo.vinput.DFfd_YGp.min.js";
+import { m as d, T as g, e as b } from "./revolugo.webcomponentwrapper.CwAC855u.min.js";
+import { I as a, R as v, r as x, a as h } from "./revolugo.vuetify.BEdap6Ni.min.js";
+import { q as c, i as u, h as $, k as S } from "./revolugo.revolugo-config.B9n_CElG.min.js";
+import { V } from "./revolugo.i18n.BIDah4Hr.min.js";
+import { L as y } from "./revolugo.index.Dx0TIvP-.min.js";
+function f(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 I = d(g).extend({
+  name: "v-counter",
+  functional: !0,
+  props: {
+    value: {
+      type: [Number, String],
+      default: ""
+    },
+    max: [Number, String]
+  },
+  render(e, t) {
+    const {
+      props: i
+    } = t, s = parseInt(i.max, 10), n = parseInt(i.value, 10), r = s ? `${n} / ${s}` : String(i.value), o = s && n > s;
+    return e("div", {
+      staticClass: "v-counter",
+      class: {
+        "error--text": o,
+        ...b(t)
+      }
+    }, r);
+  }
+});
+function E(e) {
+  return V.extend({
+    name: "intersectable",
+    data: () => ({
+      isIntersecting: !1
+    }),
+    mounted() {
+      a.inserted(this.$el, {
+        name: "intersect",
+        value: this.onObserve
+      }, this.$vnode);
+    },
+    destroyed() {
+      a.unbind(this.$el, {
+        name: "intersect",
+        value: this.onObserve
+      }, this.$vnode);
+    },
+    methods: {
+      onObserve(t, i, s) {
+        if (this.isIntersecting = s, !!s)
+          for (let n = 0, r = e.onVisible.length; n < r; n++) {
+            const o = this[e.onVisible[n]];
+            if (typeof o == "function") {
+              o();
+              continue;
+            }
+            c(e.onVisible[n] + " method is not available on the instance but referenced in intersectable mixin options");
+          }
+      }
+    }
+  });
+}
+const L = d(l, E({
+  onVisible: ["onResize", "tryAutofocus"]
+}), y), w = ["color", "file", "time", "date", "datetime-local", "week", "month"], F = L.extend().extend({
+  name: "v-text-field",
+  directives: {
+    resize: v,
+    ripple: x
+  },
+  inheritAttrs: !1,
+  props: {
+    appendOuterIcon: String,
+    autofocus: Boolean,
+    clearable: Boolean,
+    clearIcon: {
+      type: String,
+      default: "$clear"
+    },
+    counter: [Boolean, Number, String],
+    counterValue: Function,
+    filled: Boolean,
+    flat: Boolean,
+    fullWidth: Boolean,
+    label: String,
+    outlined: Boolean,
+    placeholder: String,
+    prefix: String,
+    prependInnerIcon: String,
+    persistentPlaceholder: Boolean,
+    reverse: Boolean,
+    rounded: Boolean,
+    shaped: Boolean,
+    singleLine: Boolean,
+    solo: Boolean,
+    soloInverted: Boolean,
+    suffix: String,
+    type: {
+      type: String,
+      default: "text"
+    }
+  },
+  data: () => ({
+    badInput: !1,
+    labelWidth: 0,
+    prefixWidth: 0,
+    prependWidth: 0,
+    initialValue: null,
+    isBooted: !1,
+    isClearing: !1
+  }),
+  computed: {
+    classes() {
+      return {
+        ...l.options.computed.classes.call(this),
+        "v-text-field": !0,
+        "v-text-field--full-width": this.fullWidth,
+        "v-text-field--prefix": this.prefix,
+        "v-text-field--single-line": this.isSingle,
+        "v-text-field--solo": this.isSolo,
+        "v-text-field--solo-inverted": this.soloInverted,
+        "v-text-field--solo-flat": this.flat,
+        "v-text-field--filled": this.filled,
+        "v-text-field--is-booted": this.isBooted,
+        "v-text-field--enclosed": this.isEnclosed,
+        "v-text-field--reverse": this.reverse,
+        "v-text-field--outlined": this.outlined,
+        "v-text-field--placeholder": this.placeholder,
+        "v-text-field--rounded": this.rounded,
+        "v-text-field--shaped": this.shaped
+      };
+    },
+    computedColor() {
+      const e = p.options.computed.computedColor.call(this);
+      return !this.soloInverted || !this.isFocused ? e : this.color || "primary";
+    },
+    computedCounterValue() {
+      return typeof this.counterValue == "function" ? this.counterValue(this.internalValue) : [...(this.internalValue || "").toString()].length;
+    },
+    hasCounter() {
+      return this.counter !== !1 && this.counter != null;
+    },
+    hasDetails() {
+      return l.options.computed.hasDetails.call(this) || this.hasCounter;
+    },
+    internalValue: {
+      get() {
+        return this.lazyValue;
+      },
+      set(e) {
+        this.lazyValue = e, this.$emit("input", this.lazyValue);
+      }
+    },
+    isDirty() {
+      var e;
+      return ((e = this.lazyValue) === null || e === void 0 ? void 0 : e.toString().length) > 0 || this.badInput;
+    },
+    isEnclosed() {
+      return this.filled || this.isSolo || this.outlined;
+    },
+    isLabelActive() {
+      return this.isDirty || w.includes(this.type);
+    },
+    isSingle() {
+      return this.isSolo || this.singleLine || this.fullWidth || // https://material.io/components/text-fields/#filled-text-field
+      this.filled && !this.hasLabel;
+    },
+    isSolo() {
+      return this.solo || this.soloInverted;
+    },
+    labelPosition() {
+      let e = this.prefix && !this.labelValue ? this.prefixWidth : 0;
+      return this.labelValue && this.prependWidth && (e -= this.prependWidth), this.$vuetify.rtl === this.reverse ? {
+        left: e,
+        right: "auto"
+      } : {
+        left: "auto",
+        right: e
+      };
+    },
+    showLabel() {
+      return this.hasLabel && !(this.isSingle && this.labelValue);
+    },
+    labelValue() {
+      return this.isFocused || this.isLabelActive || this.persistentPlaceholder;
+    }
+  },
+  watch: {
+    // labelValue: 'setLabelWidth', // moved to mounted, see #11533
+    outlined: "setLabelWidth",
+    label() {
+      this.$nextTick(this.setLabelWidth);
+    },
+    prefix() {
+      this.$nextTick(this.setPrefixWidth);
+    },
+    isFocused: "updateValue",
+    value(e) {
+      this.lazyValue = e;
+    }
+  },
+  created() {
+    this.$attrs.hasOwnProperty("box") && u("box", "filled", this), this.$attrs.hasOwnProperty("browser-autocomplete") && u("browser-autocomplete", "autocomplete", this), this.shaped && !(this.filled || this.outlined || this.isSolo) && c("shaped should be used with either filled or outlined", this);
+  },
+  mounted() {
+    this.$watch(() => this.labelValue, this.setLabelWidth), this.autofocus && this.tryAutofocus(), requestAnimationFrame(() => {
+      this.isBooted = !0, requestAnimationFrame(() => {
+        this.isIntersecting || this.onResize();
+      });
+    });
+  },
+  methods: {
+    /** @public */
+    focus() {
+      this.onFocus();
+    },
+    /** @public */
+    blur(e) {
+      window.requestAnimationFrame(() => {
+        this.$refs.input && this.$refs.input.blur();
+      });
+    },
+    clearableCallback() {
+      this.$refs.input && this.$refs.input.focus(), this.$nextTick(() => this.internalValue = null);
+    },
+    genAppendSlot() {
+      const e = [];
+      return this.$slots["append-outer"] ? e.push(this.$slots["append-outer"]) : this.appendOuterIcon && e.push(this.genIcon("appendOuter")), this.genSlot("append", "outer", e);
+    },
+    genPrependInnerSlot() {
+      const e = [];
+      return this.$slots["prepend-inner"] ? e.push(this.$slots["prepend-inner"]) : this.prependInnerIcon && e.push(this.genIcon("prependInner")), this.genSlot("prepend", "inner", e);
+    },
+    genIconSlot() {
+      const e = [];
+      return this.$slots.append ? e.push(this.$slots.append) : this.appendIcon && e.push(this.genIcon("append")), this.genSlot("append", "inner", e);
+    },
+    genInputSlot() {
+      const e = l.options.methods.genInputSlot.call(this), t = this.genPrependInnerSlot();
+      return t && (e.children = e.children || [], e.children.unshift(t)), e;
+    },
+    genClearIcon() {
+      return this.clearable ? this.isDirty ? this.genSlot("append", "inner", [this.genIcon("clear", this.clearableCallback)]) : this.genSlot("append", "inner", [this.$createElement("div")]) : null;
+    },
+    genCounter() {
+      var e, t, i;
+      if (!this.hasCounter)
+        return null;
+      const s = this.counter === !0 ? this.attrs$.maxlength : this.counter, n = {
+        dark: this.dark,
+        light: this.light,
+        max: s,
+        value: this.computedCounterValue
+      };
+      return (i = (t = (e = this.$scopedSlots).counter) === null || t === void 0 ? void 0 : t.call(e, {
+        props: n
+      })) !== null && i !== void 0 ? i : this.$createElement(I, {
+        props: n
+      });
+    },
+    genControl() {
+      return l.options.methods.genControl.call(this);
+    },
+    genDefaultSlot() {
+      return [this.genFieldset(), this.genTextFieldSlot(), this.genClearIcon(), this.genIconSlot(), this.genProgress()];
+    },
+    genFieldset() {
+      return this.outlined ? this.$createElement("fieldset", {
+        attrs: {
+          "aria-hidden": !0
+        }
+      }, [this.genLegend()]) : null;
+    },
+    genLabel() {
+      if (!this.showLabel)
+        return null;
+      const e = {
+        props: {
+          absolute: !0,
+          color: this.validationState,
+          dark: this.dark,
+          disabled: this.isDisabled,
+          focused: !this.isSingle && (this.isFocused || !!this.validationState),
+          for: this.computedId,
+          left: this.labelPosition.left,
+          light: this.light,
+          right: this.labelPosition.right,
+          value: this.labelValue
+        }
+      };
+      return this.$createElement(m, e, this.$slots.label || this.label);
+    },
+    genLegend() {
+      const e = !this.singleLine && (this.labelValue || this.isDirty) ? this.labelWidth : 0, t = this.$createElement("span", {
+        domProps: {
+          innerHTML: "&#8203;"
+        },
+        staticClass: "notranslate"
+      });
+      return this.$createElement("legend", {
+        style: {
+          width: this.isSingle ? void 0 : $(e)
+        }
+      }, [t]);
+    },
+    genInput() {
+      const e = Object.assign({}, this.listeners$);
+      delete e.change;
+      const {
+        title: t,
+        ...i
+      } = this.attrs$;
+      return this.$createElement("input", {
+        style: {},
+        domProps: {
+          value: this.type === "number" && Object.is(this.lazyValue, -0) ? "-0" : this.lazyValue
+        },
+        attrs: {
+          ...i,
+          autofocus: this.autofocus,
+          disabled: this.isDisabled,
+          id: this.computedId,
+          placeholder: this.persistentPlaceholder || this.isFocused || !this.hasLabel ? this.placeholder : void 0,
+          readonly: this.isReadonly,
+          type: this.type
+        },
+        on: Object.assign(e, {
+          blur: this.onBlur,
+          input: this.onInput,
+          focus: this.onFocus,
+          keydown: this.onKeyDown
+        }),
+        ref: "input",
+        directives: [{
+          name: "resize",
+          modifiers: {
+            quiet: !0
+          },
+          value: this.onResize
+        }]
+      });
+    },
+    genMessages() {
+      if (!this.showDetails)
+        return null;
+      const e = l.options.methods.genMessages.call(this), t = this.genCounter();
+      return this.$createElement("div", {
+        staticClass: "v-text-field__details"
+      }, [e, t]);
+    },
+    genTextFieldSlot() {
+      return this.$createElement("div", {
+        staticClass: "v-text-field__slot"
+      }, [this.genLabel(), this.prefix ? this.genAffix("prefix") : null, this.genInput(), this.suffix ? this.genAffix("suffix") : null]);
+    },
+    genAffix(e) {
+      return this.$createElement("div", {
+        class: `v-text-field__${e}`,
+        ref: e
+      }, this[e]);
+    },
+    onBlur(e) {
+      this.isFocused = !1, e && this.$nextTick(() => this.$emit("blur", e));
+    },
+    onClick() {
+      this.isFocused || this.isDisabled || !this.$refs.input || this.$refs.input.focus();
+    },
+    onFocus(e) {
+      if (!this.$refs.input)
+        return;
+      const t = h(this.$el);
+      if (t) {
+        if (t.activeElement !== this.$refs.input)
+          return this.$refs.input.focus();
+        this.isFocused || (this.isFocused = !0, e && this.$emit("focus", e));
+      }
+    },
+    onInput(e) {
+      const t = e.target;
+      this.internalValue = t.value, this.badInput = t.validity && t.validity.badInput;
+    },
+    onKeyDown(e) {
+      e.keyCode === S.enter && this.lazyValue !== this.initialValue && (this.initialValue = this.lazyValue, this.$emit("change", this.initialValue)), this.$emit("keydown", e);
+    },
+    onMouseDown(e) {
+      e.target !== this.$refs.input && (e.preventDefault(), e.stopPropagation()), l.options.methods.onMouseDown.call(this, e);
+    },
+    onMouseUp(e) {
+      this.hasMouseDown && this.focus(), l.options.methods.onMouseUp.call(this, e);
+    },
+    setLabelWidth() {
+      this.outlined && (this.labelWidth = this.$refs.label ? Math.min(this.$refs.label.scrollWidth * 0.75 + 6, this.$el.offsetWidth - 24) : 0);
+    },
+    setPrefixWidth() {
+      this.$refs.prefix && (this.prefixWidth = this.$refs.prefix.offsetWidth);
+    },
+    setPrependWidth() {
+      !this.outlined || !this.$refs["prepend-inner"] || (this.prependWidth = this.$refs["prepend-inner"].offsetWidth);
+    },
+    tryAutofocus() {
+      if (!this.autofocus || typeof document > "u" || !this.$refs.input)
+        return !1;
+      const e = h(this.$el);
+      return !e || e.activeElement === this.$refs.input ? !1 : (this.$refs.input.focus(), !0);
+    },
+    updateValue(e) {
+      this.hasColor = e, e ? this.initialValue = this.lazyValue : this.initialValue !== this.lazyValue && this.$emit("change", this.lazyValue);
+    },
+    onResize() {
+      this.setLabelWidth(), this.setPrefixWidth(), this.setPrependWidth();
+    }
+  }
+});
+f("css/revolugo.vtextfield.BliJY6uv.css");
+export {
+  F as _
+};
+//# sourceMappingURL=revolugo.vtextfield.C9nZE6f1.min.js.map