@revolugo/elements 5.5.1-beta.4 → 5.5.1-beta.5

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

@@ -0,0 +1,43 @@
+import { V as n } from "./revolugo.i18n.BIDah4Hr.min.js";
+import { g as r } from "./revolugo.revolugo-config.CYwmIqDC.min.js";
+function a(t) {
+  return function(o, i) {
+    for (const e in i)
+      Object.prototype.hasOwnProperty.call(o, e) || this.$delete(this.$data[t], e);
+    for (const e in o)
+      this.$set(this.$data[t], e, o[e]);
+  };
+}
+const h = n.extend({
+  data: () => ({
+    attrs$: {},
+    listeners$: {}
+  }),
+  created() {
+    this.$watch("$attrs", a("attrs$"), {
+      immediate: !0
+    }), this.$watch("$listeners", a("listeners$"), {
+      immediate: !0
+    });
+  }
+}), s = {
+  absolute: Boolean,
+  bottom: Boolean,
+  fixed: Boolean,
+  left: Boolean,
+  right: Boolean,
+  top: Boolean
+};
+function l(t = []) {
+  return n.extend({
+    name: "positionable",
+    props: t.length ? r(s, t) : s
+  });
+}
+const $ = l();
+export {
+  h as B,
+  $ as P,
+  l as f
+};
+//# sourceMappingURL=revolugo.index.BDqD4brj.min.js.map

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

@@ -0,0 +1,270 @@
+import { A as f, b as r, S as c } from "./revolugo.index.DAkBpJ0g.min.js";
+import { f as l } from "./revolugo.index.BDqD4brj.min.js";
+import { m as d } from "./revolugo.webcomponentwrapper.B_LKAOR9.min.js";
+import { h } from "./revolugo.revolugo-config.CYwmIqDC.min.js";
+const u = d(c, l(["top", "right", "bottom", "left", "absolute"]), f, r), w = u.extend().extend({
+  name: "menuable",
+  props: {
+    allowOverflow: Boolean,
+    light: Boolean,
+    dark: Boolean,
+    maxWidth: {
+      type: [Number, String],
+      default: "auto"
+    },
+    minWidth: [Number, String],
+    nudgeBottom: {
+      type: [Number, String],
+      default: 0
+    },
+    nudgeLeft: {
+      type: [Number, String],
+      default: 0
+    },
+    nudgeRight: {
+      type: [Number, String],
+      default: 0
+    },
+    nudgeTop: {
+      type: [Number, String],
+      default: 0
+    },
+    nudgeWidth: {
+      type: [Number, String],
+      default: 0
+    },
+    offsetOverflow: Boolean,
+    positionX: {
+      type: Number,
+      default: null
+    },
+    positionY: {
+      type: Number,
+      default: null
+    },
+    zIndex: {
+      type: [Number, String],
+      default: null
+    }
+  },
+  data: () => ({
+    activatorNode: [],
+    absoluteX: 0,
+    absoluteY: 0,
+    activatedBy: null,
+    activatorFixed: !1,
+    dimensions: {
+      activator: {
+        top: 0,
+        left: 0,
+        bottom: 0,
+        right: 0,
+        width: 0,
+        height: 0,
+        offsetTop: 0,
+        scrollHeight: 0,
+        offsetLeft: 0
+      },
+      content: {
+        top: 0,
+        left: 0,
+        bottom: 0,
+        right: 0,
+        width: 0,
+        height: 0,
+        offsetTop: 0,
+        scrollHeight: 0
+      }
+    },
+    relativeYOffset: 0,
+    hasJustFocused: !1,
+    hasWindow: !1,
+    inputActivator: !1,
+    isContentActive: !1,
+    pageWidth: 0,
+    pageYOffset: 0,
+    stackClass: "v-menu__content--active",
+    stackMinZIndex: 6
+  }),
+  computed: {
+    computedLeft() {
+      const t = this.dimensions.activator, e = this.dimensions.content, i = (this.attach !== !1 ? t.offsetLeft : t.left) || 0, o = Math.max(t.width, e.width);
+      let s = 0;
+      if (s += i, (this.left || this.$vuetify.rtl && !this.right) && (s -= o - t.width), this.offsetX) {
+        const n = isNaN(Number(this.maxWidth)) ? t.width : Math.min(t.width, Number(this.maxWidth));
+        s += this.left ? -n : t.width;
+      }
+      return this.nudgeLeft && (s -= parseInt(this.nudgeLeft)), this.nudgeRight && (s += parseInt(this.nudgeRight)), s;
+    },
+    computedTop() {
+      const t = this.dimensions.activator, e = this.dimensions.content;
+      let i = 0;
+      return this.top && (i += t.height - e.height), this.attach !== !1 ? i += t.offsetTop : i += t.top + this.pageYOffset, this.offsetY && (i += this.top ? -t.height : t.height), this.nudgeTop && (i -= parseInt(this.nudgeTop)), this.nudgeBottom && (i += parseInt(this.nudgeBottom)), i;
+    },
+    hasActivator() {
+      return !!this.$slots.activator || !!this.$scopedSlots.activator || !!this.activator || !!this.inputActivator;
+    },
+    absoluteYOffset() {
+      return this.pageYOffset - this.relativeYOffset;
+    }
+  },
+  watch: {
+    disabled(t) {
+      t && this.callDeactivate();
+    },
+    isActive(t) {
+      this.disabled || (t ? this.callActivate() : this.callDeactivate());
+    },
+    positionX: "updateDimensions",
+    positionY: "updateDimensions"
+  },
+  beforeMount() {
+    this.hasWindow = typeof window < "u", this.hasWindow && window.addEventListener("resize", this.updateDimensions, !1);
+  },
+  beforeDestroy() {
+    this.hasWindow && window.removeEventListener("resize", this.updateDimensions, !1);
+  },
+  methods: {
+    absolutePosition() {
+      return {
+        offsetTop: this.positionY || this.absoluteY,
+        offsetLeft: this.positionX || this.absoluteX,
+        scrollHeight: 0,
+        top: this.positionY || this.absoluteY,
+        bottom: this.positionY || this.absoluteY,
+        left: this.positionX || this.absoluteX,
+        right: this.positionX || this.absoluteX,
+        height: 0,
+        width: 0
+      };
+    },
+    activate() {
+    },
+    calcLeft(t) {
+      return h(this.attach !== !1 ? this.computedLeft : this.calcXOverflow(this.computedLeft, t));
+    },
+    calcTop() {
+      return h(this.attach !== !1 ? this.computedTop : this.calcYOverflow(this.computedTop));
+    },
+    calcXOverflow(t, e) {
+      const i = t + e - this.pageWidth + 12;
+      return (!this.left || this.right) && i > 0 ? t = Math.max(t - i, 0) : t = Math.max(t, 12), t + this.getOffsetLeft();
+    },
+    calcYOverflow(t) {
+      const e = this.getInnerHeight(), i = this.absoluteYOffset + e, o = this.dimensions.activator, s = this.dimensions.content.height, n = t + s, a = i < n;
+      return a && this.offsetOverflow && // If we don't have enough room to offset
+      // the overflow, don't offset
+      o.top > s ? t = this.pageYOffset + (o.top - s) : a && !this.allowOverflow ? t = i - s - 12 : t < this.absoluteYOffset && !this.allowOverflow && (t = this.absoluteYOffset + 12), t < 12 ? 12 : t;
+    },
+    callActivate() {
+      this.hasWindow && this.activate();
+    },
+    callDeactivate() {
+      this.isContentActive = !1, this.deactivate();
+    },
+    checkForPageYOffset() {
+      this.hasWindow && (this.pageYOffset = this.activatorFixed ? 0 : this.getOffsetTop());
+    },
+    checkActivatorFixed() {
+      if (this.attach !== !1) {
+        this.activatorFixed = !1;
+        return;
+      }
+      let t = this.getActivator();
+      for (; t; ) {
+        if (window.getComputedStyle(t).position === "fixed") {
+          this.activatorFixed = !0;
+          return;
+        }
+        t = t.offsetParent;
+      }
+      this.activatorFixed = !1;
+    },
+    deactivate() {
+    },
+    genActivatorListeners() {
+      const t = f.options.methods.genActivatorListeners.call(this), e = t.click;
+      return e && (t.click = (i) => {
+        this.openOnClick && e && e(i), this.absoluteX = i.clientX, this.absoluteY = i.clientY;
+      }), t;
+    },
+    getInnerHeight() {
+      return this.hasWindow ? window.innerHeight || document.documentElement.clientHeight : 0;
+    },
+    getOffsetLeft() {
+      return this.hasWindow ? window.pageXOffset || document.documentElement.scrollLeft : 0;
+    },
+    getOffsetTop() {
+      return this.hasWindow ? window.pageYOffset || document.documentElement.scrollTop : 0;
+    },
+    getRoundedBoundedClientRect(t) {
+      const e = t.getBoundingClientRect();
+      return {
+        top: Math.round(e.top),
+        left: Math.round(e.left),
+        bottom: Math.round(e.bottom),
+        right: Math.round(e.right),
+        width: Math.round(e.width),
+        height: Math.round(e.height)
+      };
+    },
+    measure(t) {
+      if (!t || !this.hasWindow)
+        return null;
+      const e = this.getRoundedBoundedClientRect(t);
+      if (this.attach !== !1) {
+        const i = window.getComputedStyle(t);
+        e.left = parseInt(i.marginLeft), e.top = parseInt(i.marginTop);
+      }
+      return e;
+    },
+    sneakPeek(t) {
+      requestAnimationFrame(() => {
+        const e = this.$refs.content;
+        if (!e || e.style.display !== "none") {
+          t();
+          return;
+        }
+        e.style.display = "inline-block", t(), e.style.display = "none";
+      });
+    },
+    startTransition() {
+      return new Promise((t) => requestAnimationFrame(() => {
+        this.isContentActive = this.hasJustFocused = this.isActive, t();
+      }));
+    },
+    updateDimensions() {
+      this.hasWindow = typeof window < "u", this.checkActivatorFixed(), this.checkForPageYOffset(), this.pageWidth = document.documentElement.clientWidth;
+      const t = {
+        activator: {
+          ...this.dimensions.activator
+        },
+        content: {
+          ...this.dimensions.content
+        }
+      };
+      if (!this.hasActivator || this.absolute)
+        t.activator = this.absolutePosition();
+      else {
+        const e = this.getActivator();
+        if (!e)
+          return;
+        t.activator = this.measure(e), t.activator.offsetLeft = e.offsetLeft, this.attach !== !1 ? t.activator.offsetTop = e.offsetTop : t.activator.offsetTop = 0;
+      }
+      this.sneakPeek(() => {
+        if (this.$refs.content) {
+          if (this.$refs.content.offsetParent) {
+            const e = this.getRoundedBoundedClientRect(this.$refs.content.offsetParent);
+            this.relativeYOffset = window.pageYOffset + e.top, t.activator.top -= this.relativeYOffset, t.activator.left -= window.pageXOffset + e.left;
+          }
+          t.content = this.measure(this.$refs.content);
+        }
+        this.dimensions = t;
+      });
+    }
+  }
+});
+export {
+  w as M
+};
+//# sourceMappingURL=revolugo.index.BNslhUAH.min.js.map

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

@@ -0,0 +1,281 @@
+import { V as n } from "./revolugo.i18n.BIDah4Hr.min.js";
+import { b as o, c as l } from "./revolugo.index.DxSal0Ur.min.js";
+import { I as h } from "./revolugo.vuetify.CjZ8kF3V.min.js";
+import { m as c, T as u, C as d } from "./revolugo.webcomponentwrapper.B_LKAOR9.min.js";
+import { f as m } from "./revolugo.index.BDqD4brj.min.js";
+import { h as i, j as g } from "./revolugo.revolugo-config.CYwmIqDC.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, r = t.slice(0, t.lastIndexOf("/") + 1) + e;
+      window.REVOLUGO_ELEMENTS_STYLES.sheets.push(r);
+      for (const s of REVOLUGO_ELEMENTS_STYLES.components)
+        s(r);
+      if (e.indexOf("fonts") >= 0) {
+        const s = document.createElement("link");
+        s.rel = "stylesheet", linK.href = r, document.head.appendChild(s);
+      }
+    }
+  } catch (t) {
+    console.error("[revolugo-elements] ", t);
+  }
+}
+function f(e = "value", t = "change") {
+  return n.extend({
+    name: "proxyable",
+    model: {
+      prop: e,
+      event: t
+    },
+    props: {
+      [e]: {
+        required: !1
+      }
+    },
+    data() {
+      return {
+        internalLazyValue: this[e]
+      };
+    },
+    computed: {
+      internalValue: {
+        get() {
+          return this.internalLazyValue;
+        },
+        set(r) {
+          r !== this.internalLazyValue && (this.internalLazyValue = r, this.$emit(t, r));
+        }
+      }
+    },
+    watch: {
+      [e](r) {
+        this.internalLazyValue = r;
+      }
+    }
+  });
+}
+const p = f(), _ = p, v = c(d, m(["absolute", "fixed", "top", "bottom"]), _, u), y = v.extend({
+  name: "v-progress-linear",
+  directives: {
+    intersect: h
+  },
+  props: {
+    active: {
+      type: Boolean,
+      default: !0
+    },
+    backgroundColor: {
+      type: String,
+      default: null
+    },
+    backgroundOpacity: {
+      type: [Number, String],
+      default: null
+    },
+    bufferValue: {
+      type: [Number, String],
+      default: 100
+    },
+    color: {
+      type: String,
+      default: "primary"
+    },
+    height: {
+      type: [Number, String],
+      default: 4
+    },
+    indeterminate: Boolean,
+    query: Boolean,
+    reverse: Boolean,
+    rounded: Boolean,
+    stream: Boolean,
+    striped: Boolean,
+    value: {
+      type: [Number, String],
+      default: 0
+    }
+  },
+  data() {
+    return {
+      internalLazyValue: this.value || 0,
+      isVisible: !0
+    };
+  },
+  computed: {
+    __cachedBackground() {
+      return this.$createElement("div", this.setBackgroundColor(this.backgroundColor || this.color, {
+        staticClass: "v-progress-linear__background",
+        style: this.backgroundStyle
+      }));
+    },
+    __cachedBar() {
+      return this.$createElement(this.computedTransition, [this.__cachedBarType]);
+    },
+    __cachedBarType() {
+      return this.indeterminate ? this.__cachedIndeterminate : this.__cachedDeterminate;
+    },
+    __cachedBuffer() {
+      return this.$createElement("div", {
+        staticClass: "v-progress-linear__buffer",
+        style: this.styles
+      });
+    },
+    __cachedDeterminate() {
+      return this.$createElement("div", this.setBackgroundColor(this.color, {
+        staticClass: "v-progress-linear__determinate",
+        style: {
+          width: i(this.normalizedValue, "%")
+        }
+      }));
+    },
+    __cachedIndeterminate() {
+      return this.$createElement("div", {
+        staticClass: "v-progress-linear__indeterminate",
+        class: {
+          "v-progress-linear__indeterminate--active": this.active
+        }
+      }, [this.genProgressBar("long"), this.genProgressBar("short")]);
+    },
+    __cachedStream() {
+      return this.stream ? this.$createElement("div", this.setTextColor(this.color, {
+        staticClass: "v-progress-linear__stream",
+        style: {
+          width: i(100 - this.normalizedBuffer, "%")
+        }
+      })) : null;
+    },
+    backgroundStyle() {
+      return {
+        opacity: this.backgroundOpacity == null ? this.backgroundColor ? 1 : 0.3 : parseFloat(this.backgroundOpacity),
+        [this.isReversed ? "right" : "left"]: i(this.normalizedValue, "%"),
+        width: i(Math.max(0, this.normalizedBuffer - this.normalizedValue), "%")
+      };
+    },
+    classes() {
+      return {
+        "v-progress-linear--absolute": this.absolute,
+        "v-progress-linear--fixed": this.fixed,
+        "v-progress-linear--query": this.query,
+        "v-progress-linear--reactive": this.reactive,
+        "v-progress-linear--reverse": this.isReversed,
+        "v-progress-linear--rounded": this.rounded,
+        "v-progress-linear--striped": this.striped,
+        "v-progress-linear--visible": this.isVisible,
+        ...this.themeClasses
+      };
+    },
+    computedTransition() {
+      return this.indeterminate ? o : l;
+    },
+    isReversed() {
+      return this.$vuetify.rtl !== this.reverse;
+    },
+    normalizedBuffer() {
+      return this.normalize(this.bufferValue);
+    },
+    normalizedValue() {
+      return this.normalize(this.internalLazyValue);
+    },
+    reactive() {
+      return !!this.$listeners.change;
+    },
+    styles() {
+      const e = {};
+      return this.active || (e.height = 0), !this.indeterminate && parseFloat(this.normalizedBuffer) !== 100 && (e.width = i(this.normalizedBuffer, "%")), e;
+    }
+  },
+  methods: {
+    genContent() {
+      const e = g(this, "default", {
+        value: this.internalLazyValue
+      });
+      return e ? this.$createElement("div", {
+        staticClass: "v-progress-linear__content"
+      }, e) : null;
+    },
+    genListeners() {
+      const e = this.$listeners;
+      return this.reactive && (e.click = this.onClick), e;
+    },
+    genProgressBar(e) {
+      return this.$createElement("div", this.setBackgroundColor(this.color, {
+        staticClass: "v-progress-linear__indeterminate",
+        class: {
+          [e]: !0
+        }
+      }));
+    },
+    onClick(e) {
+      if (!this.reactive)
+        return;
+      const {
+        width: t
+      } = this.$el.getBoundingClientRect();
+      this.internalValue = e.offsetX / t * 100;
+    },
+    onObserve(e, t, r) {
+      this.isVisible = r;
+    },
+    normalize(e) {
+      return e < 0 ? 0 : e > 100 ? 100 : parseFloat(e);
+    }
+  },
+  render(e) {
+    const t = {
+      staticClass: "v-progress-linear",
+      attrs: {
+        role: "progressbar",
+        "aria-valuemin": 0,
+        "aria-valuemax": this.normalizedBuffer,
+        "aria-valuenow": this.indeterminate ? void 0 : this.normalizedValue
+      },
+      class: this.classes,
+      directives: [{
+        name: "intersect",
+        value: this.onObserve
+      }],
+      style: {
+        bottom: this.bottom ? 0 : void 0,
+        height: this.active ? i(this.height) : 0,
+        top: this.top ? 0 : void 0
+      },
+      on: this.genListeners()
+    };
+    return e("div", t, [this.__cachedStream, this.__cachedBackground, this.__cachedBuffer, this.__cachedBar, this.genContent()]);
+  }
+}), L = n.extend().extend({
+  name: "loadable",
+  props: {
+    loading: {
+      type: [Boolean, String],
+      default: !1
+    },
+    loaderHeight: {
+      type: [Number, String],
+      default: 2
+    }
+  },
+  methods: {
+    genProgress() {
+      return this.loading === !1 ? null : this.$slots.progress || this.$createElement(y, {
+        props: {
+          absolute: !0,
+          color: this.loading === !0 || this.loading === "" ? this.color || "primary" : this.loading,
+          height: this.loaderHeight,
+          indeterminate: !0
+        }
+      });
+    }
+  }
+});
+a("css/revolugo.index.DXv5c7NS.css");
+export {
+  L,
+  _ as P,
+  y as _
+};
+//# sourceMappingURL=revolugo.index.BPR3XlHM.min.js.map

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

@@ -0,0 +1,13 @@
+import { V as n } from "./revolugo.i18n.BIDah4Hr.min.js";
+const t = n.extend({
+  name: "transitionable",
+  props: {
+    mode: String,
+    origin: String,
+    transition: String
+  }
+});
+export {
+  t as T
+};
+//# sourceMappingURL=revolugo.index.BafzMKRk.min.js.map

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

@@ -0,0 +1,9 @@
+import { c as t } from "./revolugo.revolugo-config.CYwmIqDC.min.js";
+t("v-list-item__action-text", "span");
+const e = t("v-list-item__content", "div"), s = t("v-list-item__title", "div"), n = t("v-list-item__subtitle", "div");
+export {
+  s as V,
+  e as a,
+  n as b
+};
+//# sourceMappingURL=revolugo.index.C66sAn8l.min.js.map

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

@@ -0,0 +1,15 @@
+import { V as a } from "./revolugo.i18n.BIDah4Hr.min.js";
+import { d as e } from "./revolugo.revolugo-config.CYwmIqDC.min.js";
+const r = a.extend({
+  name: "comparable",
+  props: {
+    valueComparator: {
+      type: Function,
+      default: e
+    }
+  }
+});
+export {
+  r as C
+};
+//# sourceMappingURL=revolugo.index.CY4z9JfD.min.js.map

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

@@ -0,0 +1,9 @@
+import { c as t } from "./revolugo.revolugo-config.CYwmIqDC.min.js";
+const c = t("v-card__actions"), r = t("v-card__subtitle"), s = t("v-card__text"), e = t("v-card__title");
+export {
+  s as V,
+  c as a,
+  e as b,
+  r as c
+};
+//# sourceMappingURL=revolugo.index.Ce9_ljIe.min.js.map

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

@@ -0,0 +1,42 @@
+import { T as t } from "./revolugo.webcomponentwrapper.B_LKAOR9.min.js";
+import { V as i } from "./revolugo.i18n.BIDah4Hr.min.js";
+const a = t.extend({
+  name: "v-theme-provider",
+  props: {
+    root: Boolean
+  },
+  computed: {
+    isDark() {
+      return this.root ? this.rootIsDark : t.options.computed.isDark.call(this);
+    }
+  },
+  render() {
+    return this.$slots.default && this.$slots.default.find((e) => !e.isComment && e.text !== " ");
+  }
+}), o = i.extend({
+  name: "returnable",
+  props: {
+    returnValue: null
+  },
+  data: () => ({
+    isActive: !1,
+    originalValue: null
+  }),
+  watch: {
+    isActive(e) {
+      e ? this.originalValue = this.returnValue : this.$emit("update:return-value", this.originalValue);
+    }
+  },
+  methods: {
+    save(e) {
+      this.originalValue = e, setTimeout(() => {
+        this.isActive = !1;
+      });
+    }
+  }
+});
+export {
+  o as R,
+  a as V
+};
+//# sourceMappingURL=revolugo.index.CkzsvJ2p.min.js.map