@revolugo/elements 6.8.2-beta.4 → 6.8.2-beta.41

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

@@ -0,0 +1,463 @@
+import { ag as j, a as y, bY as X, cI as A, a6 as R, H as d, a2 as w, a4 as B, a1 as F, a7 as P, an as q, a9 as D, k as O, O as I, ap as J, af as Q, am as Z, aL as z, c3 as ee, p as ae, b4 as ne, Y as te, X as se, aS as L, W as le, aK as ie, aE as ue, aM as oe, a_ as re, a3 as $ } from "./revolugo.index.wc.BQFDR_sN.min.js";
+import { V as de } from "./revolugo.vicon.DRzW88LO.min.js";
+import { z as ce, s as ve, m as fe } from "./revolugo.index.DjbDWbUi.min.js";
+import { d as me, u as N, M as ge, p as ye, m as U, n as pe, o as he } from "./revolugo.webcomponentwrapper.DZKKwbYN.min.js";
+function W(e) {
+  try {
+    if (typeof document < "u") {
+      window.REVOLUGO_ELEMENTS_STYLES = window.REVOLUGO_ELEMENTS_STYLES || {
+        sheets: [],
+        components: []
+      };
+      const s = import.meta.url, u = s.slice(0, s.lastIndexOf("/") + 1) + e;
+      window.REVOLUGO_ELEMENTS_STYLES.sheets.push(u);
+      for (const n of REVOLUGO_ELEMENTS_STYLES.components)
+        n(u);
+      if (e.indexOf("fonts") >= 0) {
+        const n = document.createElement("link");
+        n.rel = "stylesheet", linK.href = u, document.head.appendChild(n);
+      }
+    }
+  } catch (s) {
+    console.error("[revolugo-elements] ", s);
+  }
+}
+function Ve(e) {
+  const {
+    t: s
+  } = j();
+  function u(n) {
+    let {
+      name: o
+    } = n;
+    const a = {
+      prepend: "prependAction",
+      prependInner: "prependAction",
+      append: "appendAction",
+      appendInner: "appendAction",
+      clear: "clear"
+    }[o], i = e[`onClick:${o}`];
+    function g(f) {
+      f.key !== "Enter" && f.key !== " " || (f.preventDefault(), f.stopPropagation(), X(i, new PointerEvent("click", f)));
+    }
+    const h = i && a ? s(`$vuetify.input.${a}`, e.label ?? "") : void 0;
+    return y(de, {
+      icon: e[`${o}Icon`],
+      "aria-label": h,
+      onClick: i,
+      onKeydown: g
+    }, null);
+  }
+  return {
+    InputIcon: u
+  };
+}
+const Se = w({
+  focused: Boolean,
+  "onUpdate:focused": B()
+}, "focus");
+function De(e) {
+  let s = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : A();
+  const u = R(e, "focused"), n = d(() => ({
+    [`${s}--focused`]: u.value
+  }));
+  function o() {
+    u.value = !0;
+  }
+  function a() {
+    u.value = !1;
+  }
+  return {
+    focusClasses: n,
+    isFocused: u,
+    focus: o,
+    blur: a
+  };
+}
+const be = w({
+  active: Boolean,
+  color: String,
+  messages: {
+    type: [Array, String],
+    default: () => []
+  },
+  ...U(),
+  ...ye({
+    transition: {
+      component: ce,
+      leaveAbsolute: !0,
+      group: !0
+    }
+  })
+}, "VMessages"), Ee = F()({
+  name: "VMessages",
+  props: be(),
+  setup(e, s) {
+    let {
+      slots: u
+    } = s;
+    const n = d(() => P(e.messages)), {
+      textColorClasses: o,
+      textColorStyles: a
+    } = me(d(() => e.color));
+    return N(() => y(ge, {
+      transition: e.transition,
+      tag: "div",
+      class: ["v-messages", o.value, e.class],
+      style: [a.value, e.style]
+    }, {
+      default: () => [e.active && n.value.map((i, g) => y("div", {
+        class: "v-messages__message",
+        key: `${g}-${n.value}`
+      }, [u.message ? u.message({
+        message: i
+      }) : i]))]
+    })), {};
+  }
+}), Y = Symbol.for("vuetify:form"), Oe = w({
+  disabled: Boolean,
+  fastFail: Boolean,
+  readonly: Boolean,
+  modelValue: {
+    type: Boolean,
+    default: null
+  },
+  validateOn: {
+    type: String,
+    default: "input"
+  }
+}, "form");
+function Re(e) {
+  const s = R(e, "modelValue"), u = d(() => e.disabled), n = d(() => e.readonly), o = D(!1), a = O([]), i = O([]);
+  async function g() {
+    const t = [];
+    let l = !0;
+    i.value = [], o.value = !0;
+    for (const c of a.value) {
+      const r = await c.validate();
+      if (r.length > 0 && (l = !1, t.push({
+        id: c.id,
+        errorMessages: r
+      })), !l && e.fastFail) break;
+    }
+    return i.value = t, o.value = !1, {
+      valid: l,
+      errors: i.value
+    };
+  }
+  function h() {
+    a.value.forEach((t) => t.reset());
+  }
+  function f() {
+    a.value.forEach((t) => t.resetValidation());
+  }
+  return I(a, () => {
+    let t = 0, l = 0;
+    const c = [];
+    for (const r of a.value)
+      r.isValid === !1 ? (l++, c.push({
+        id: r.id,
+        errorMessages: r.errorMessages
+      })) : r.isValid === !0 && t++;
+    i.value = c, s.value = l > 0 ? !1 : t === a.value.length ? !0 : null;
+  }, {
+    deep: !0,
+    flush: "post"
+  }), J(Y, {
+    register: (t) => {
+      let {
+        id: l,
+        vm: c,
+        validate: r,
+        reset: S,
+        resetValidation: V
+      } = t;
+      a.value.some((E) => E.id === l), a.value.push({
+        id: l,
+        validate: r,
+        reset: S,
+        resetValidation: V,
+        vm: Z(c),
+        isValid: null,
+        errorMessages: []
+      });
+    },
+    unregister: (t) => {
+      a.value = a.value.filter((l) => l.id !== t);
+    },
+    update: (t, l, c) => {
+      const r = a.value.find((S) => S.id === t);
+      r && (r.isValid = l, r.errorMessages = c);
+    },
+    isDisabled: u,
+    isReadonly: n,
+    isValidating: o,
+    isValid: s,
+    items: a,
+    validateOn: Q(e, "validateOn")
+  }), {
+    errors: i,
+    isDisabled: u,
+    isReadonly: n,
+    isValidating: o,
+    isValid: s,
+    items: a,
+    validate: g,
+    reset: h,
+    resetValidation: f
+  };
+}
+function Me(e) {
+  const s = q(Y, null);
+  return {
+    ...s,
+    isReadonly: d(() => !!(e?.readonly ?? s?.isReadonly.value)),
+    isDisabled: d(() => !!(e?.disabled ?? s?.isDisabled.value))
+  };
+}
+const ke = w({
+  disabled: {
+    type: Boolean,
+    default: null
+  },
+  error: Boolean,
+  errorMessages: {
+    type: [Array, String],
+    default: () => []
+  },
+  maxErrors: {
+    type: [Number, String],
+    default: 1
+  },
+  name: String,
+  label: String,
+  readonly: {
+    type: Boolean,
+    default: null
+  },
+  rules: {
+    type: Array,
+    default: () => []
+  },
+  modelValue: null,
+  validateOn: String,
+  validationValue: null,
+  ...Se()
+}, "validation");
+function Ie(e) {
+  let s = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : A(), u = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : z();
+  const n = R(e, "modelValue"), o = d(() => e.validationValue === void 0 ? n.value : e.validationValue), a = Me(e), i = O([]), g = D(!0), h = d(() => !!(P(n.value === "" ? null : n.value).length || P(o.value === "" ? null : o.value).length)), f = d(() => e.errorMessages?.length ? P(e.errorMessages).concat(i.value).slice(0, Math.max(0, Number(e.maxErrors))) : i.value), t = d(() => {
+    let m = (e.validateOn ?? a.validateOn?.value) || "input";
+    m === "lazy" && (m = "input lazy"), m === "eager" && (m = "input eager");
+    const v = new Set(m?.split(" ") ?? []);
+    return {
+      input: v.has("input"),
+      blur: v.has("blur") || v.has("input") || v.has("invalid-input"),
+      invalidInput: v.has("invalid-input"),
+      lazy: v.has("lazy"),
+      eager: v.has("eager")
+    };
+  }), l = d(() => e.error || e.errorMessages?.length ? !1 : e.rules.length ? g.value ? i.value.length || t.value.lazy ? null : !0 : !i.value.length : !0), c = D(!1), r = d(() => ({
+    [`${s}--error`]: l.value === !1,
+    [`${s}--dirty`]: h.value,
+    [`${s}--disabled`]: a.isDisabled.value,
+    [`${s}--readonly`]: a.isReadonly.value
+  })), S = ee("validation"), V = d(() => e.name ?? ae(u));
+  ne(() => {
+    a.register?.({
+      id: V.value,
+      vm: S,
+      validate: p,
+      reset: E,
+      resetValidation: M
+    });
+  }), te(() => {
+    a.unregister?.(V.value);
+  }), se(async () => {
+    t.value.lazy || await p(!t.value.eager), a.update?.(V.value, l.value, f.value);
+  }), L(() => t.value.input || t.value.invalidInput && l.value === !1, () => {
+    I(o, () => {
+      if (o.value != null)
+        p();
+      else if (e.focused) {
+        const m = I(() => e.focused, (v) => {
+          v || p(), m();
+        });
+      }
+    });
+  }), L(() => t.value.blur, () => {
+    I(() => e.focused, (m) => {
+      m || p();
+    });
+  }), I([l, f], () => {
+    a.update?.(V.value, l.value, f.value);
+  });
+  async function E() {
+    n.value = null, await le(), await M();
+  }
+  async function M() {
+    g.value = !0, t.value.lazy ? i.value = [] : await p(!t.value.eager);
+  }
+  async function p() {
+    let m = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : !1;
+    const v = [];
+    c.value = !0;
+    for (const k of e.rules) {
+      if (v.length >= Number(e.maxErrors ?? 1))
+        break;
+      const b = await (typeof k == "function" ? k : () => k)(o.value);
+      if (b !== !0) {
+        if (b !== !1 && typeof b != "string") {
+          console.warn(`${b} is not a valid value. Rule functions must return boolean true or a string.`);
+          continue;
+        }
+        v.push(b || "");
+      }
+    }
+    return i.value = v, c.value = !1, g.value = m, i.value;
+  }
+  return {
+    errorMessages: f,
+    isDirty: h,
+    isDisabled: a.isDisabled,
+    isReadonly: a.isReadonly,
+    isPristine: g,
+    isValid: l,
+    isValidating: c,
+    reset: E,
+    resetValidation: M,
+    validate: p,
+    validationClasses: r
+  };
+}
+const we = w({
+  id: String,
+  appendIcon: $,
+  centerAffix: {
+    type: Boolean,
+    default: !0
+  },
+  prependIcon: $,
+  hideDetails: [Boolean, String],
+  hideSpinButtons: Boolean,
+  hint: String,
+  persistentHint: Boolean,
+  messages: {
+    type: [Array, String],
+    default: () => []
+  },
+  direction: {
+    type: String,
+    default: "horizontal",
+    validator: (e) => ["horizontal", "vertical"].includes(e)
+  },
+  "onClick:prepend": B(),
+  "onClick:append": B(),
+  ...U(),
+  ...fe(),
+  ...re(he(), ["maxWidth", "minWidth", "width"]),
+  ...oe(),
+  ...ke()
+}, "VInput"), xe = F()({
+  name: "VInput",
+  props: {
+    ...we()
+  },
+  emits: {
+    "update:modelValue": (e) => !0
+  },
+  setup(e, s) {
+    let {
+      attrs: u,
+      slots: n,
+      emit: o
+    } = s;
+    const {
+      densityClasses: a
+    } = ve(e), {
+      dimensionStyles: i
+    } = pe(e), {
+      themeClasses: g
+    } = ie(e), {
+      rtlClasses: h
+    } = ue(), {
+      InputIcon: f
+    } = Ve(e), t = z(), l = d(() => e.id || `input-${t}`), c = d(() => `${l.value}-messages`), {
+      errorMessages: r,
+      isDirty: S,
+      isDisabled: V,
+      isReadonly: E,
+      isPristine: M,
+      isValid: p,
+      isValidating: m,
+      reset: v,
+      resetValidation: k,
+      validate: _,
+      validationClasses: b
+    } = Ie(e, "v-input", l), C = d(() => ({
+      id: l,
+      messagesId: c,
+      isDirty: S,
+      isDisabled: V,
+      isReadonly: E,
+      isPristine: M,
+      isValid: p,
+      isValidating: m,
+      reset: v,
+      resetValidation: k,
+      validate: _
+    })), x = d(() => e.errorMessages?.length || !M.value && r.value.length ? r.value : e.hint && (e.persistentHint || e.focused) ? e.hint : e.messages);
+    return N(() => {
+      const K = !!(n.prepend || e.prependIcon), G = !!(n.append || e.appendIcon), T = x.value.length > 0, H = !e.hideDetails || e.hideDetails === "auto" && (T || !!n.details);
+      return y("div", {
+        class: ["v-input", `v-input--${e.direction}`, {
+          "v-input--center-affix": e.centerAffix,
+          "v-input--hide-spin-buttons": e.hideSpinButtons
+        }, a.value, g.value, h.value, b.value, e.class],
+        style: [i.value, e.style]
+      }, [K && y("div", {
+        key: "prepend",
+        class: "v-input__prepend"
+      }, [n.prepend?.(C.value), e.prependIcon && y(f, {
+        key: "prepend-icon",
+        name: "prepend"
+      }, null)]), n.default && y("div", {
+        class: "v-input__control"
+      }, [n.default?.(C.value)]), G && y("div", {
+        key: "append",
+        class: "v-input__append"
+      }, [e.appendIcon && y(f, {
+        key: "append-icon",
+        name: "append"
+      }, null), n.append?.(C.value)]), H && y("div", {
+        id: c.value,
+        class: "v-input__details",
+        role: "alert",
+        "aria-live": "polite"
+      }, [y(Ee, {
+        active: T,
+        messages: x.value
+      }, {
+        message: n.message
+      }), n.details?.(C.value)])]);
+    }), {
+      reset: v,
+      resetValidation: k,
+      validate: _,
+      isValid: p,
+      errorMessages: r
+    };
+  }
+});
+W("css/revolugo.vinput.BPiFMorL.css");
+export {
+  xe as V,
+  Se as a,
+  Me as b,
+  Re as c,
+  Oe as d,
+  Ve as e,
+  we as m,
+  De as u
+};
+//# sourceMappingURL=revolugo.vinput.Bmu1s4Hw.min.js.map

package/dist/revolugo.vlabel.DfS27j2I.min.js

@@ -0,0 +1,48 @@
+import { u as s, m as a } from "./revolugo.webcomponentwrapper.DZKKwbYN.min.js";
+import { a1 as c, a2 as r, a as i, aM as m, a4 as E } from "./revolugo.index.wc.BQFDR_sN.min.js";
+function l(e) {
+  try {
+    if (typeof document < "u") {
+      window.REVOLUGO_ELEMENTS_STYLES = window.REVOLUGO_ELEMENTS_STYLES || {
+        sheets: [],
+        components: []
+      };
+      const o = import.meta.url, t = o.slice(0, o.lastIndexOf("/") + 1) + e;
+      window.REVOLUGO_ELEMENTS_STYLES.sheets.push(t);
+      for (const n of REVOLUGO_ELEMENTS_STYLES.components)
+        n(t);
+      if (e.indexOf("fonts") >= 0) {
+        const n = document.createElement("link");
+        n.rel = "stylesheet", linK.href = t, document.head.appendChild(n);
+      }
+    }
+  } catch (o) {
+    console.error("[revolugo-elements] ", o);
+  }
+}
+const d = r({
+  text: String,
+  onClick: E(),
+  ...a(),
+  ...m()
+}, "VLabel"), f = c()({
+  name: "VLabel",
+  props: d(),
+  setup(e, o) {
+    let {
+      slots: t
+    } = o;
+    return s(() => i("label", {
+      class: ["v-label", {
+        "v-label--clickable": !!e.onClick
+      }, e.class],
+      style: e.style,
+      onClick: e.onClick
+    }, [e.text, t.default?.()])), {};
+  }
+});
+l("css/revolugo.vlabel.BvKaKg7Y.css");
+export {
+  f as V
+};
+//# sourceMappingURL=revolugo.vlabel.DfS27j2I.min.js.map