@revolugo/elements 5.5.3 → 5.5.4-beta.0

package/dist/revolugo.vtoolbar.D3HhuFrj.min.js

@@ -0,0 +1,364 @@
+import { M as p, _ as c } from "./revolugo.vsheet.C1tyLBBd.min.js";
+import { I as m } from "./revolugo.vuetify.yojzDMFk.min.js";
+import { m as h, T as u, c as g } from "./revolugo.webcomponentwrapper.-wnE6sKX.min.js";
+import { j as n, q as f, h as r, i as S } from "./revolugo.revolugo-config.Bs_HF2Eu.min.js";
+function d(t) {
+  try {
+    if (typeof document < "u") {
+      window.REVOLUGO_ELEMENTS_STYLES = window.REVOLUGO_ELEMENTS_STYLES || {
+        sheets: [],
+        components: []
+      };
+      const e = import.meta.url, s = e.slice(0, e.lastIndexOf("/") + 1) + t;
+      window.REVOLUGO_ELEMENTS_STYLES.sheets.push(s);
+      for (const i of REVOLUGO_ELEMENTS_STYLES.components)
+        i(s);
+      if (t.indexOf("fonts") >= 0) {
+        const i = document.createElement("link");
+        i.rel = "stylesheet", linK.href = s, document.head.appendChild(i);
+      }
+    }
+  } catch (e) {
+    console.error("[revolugo-elements] ", e);
+  }
+}
+const o = h(p).extend({
+  name: "v-responsive",
+  props: {
+    aspectRatio: [String, Number],
+    contentClass: String
+  },
+  computed: {
+    computedAspectRatio() {
+      return Number(this.aspectRatio);
+    },
+    aspectStyle() {
+      return this.computedAspectRatio ? {
+        paddingBottom: 1 / this.computedAspectRatio * 100 + "%"
+      } : void 0;
+    },
+    __cachedSizer() {
+      return this.aspectStyle ? this.$createElement("div", {
+        style: this.aspectStyle,
+        staticClass: "v-responsive__sizer"
+      }) : [];
+    }
+  },
+  methods: {
+    genContent() {
+      return this.$createElement("div", {
+        staticClass: "v-responsive__content",
+        class: this.contentClass
+      }, n(this));
+    }
+  },
+  render(t) {
+    return t("div", {
+      staticClass: "v-responsive",
+      style: this.measurableStyles,
+      on: this.$listeners
+    }, [this.__cachedSizer, this.genContent()]);
+  }
+}), l = typeof window < "u" && "IntersectionObserver" in window, v = h(o, u).extend({
+  name: "v-img",
+  directives: {
+    intersect: m
+  },
+  props: {
+    alt: String,
+    contain: Boolean,
+    eager: Boolean,
+    gradient: String,
+    lazySrc: String,
+    options: {
+      type: Object,
+      // For more information on types, navigate to:
+      // https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API
+      default: () => ({
+        root: void 0,
+        rootMargin: void 0,
+        threshold: void 0
+      })
+    },
+    position: {
+      type: String,
+      default: "center center"
+    },
+    sizes: String,
+    src: {
+      type: [String, Object],
+      default: ""
+    },
+    srcset: String,
+    transition: {
+      type: [Boolean, String],
+      default: "fade-transition"
+    }
+  },
+  data() {
+    return {
+      currentSrc: "",
+      image: null,
+      isLoading: !0,
+      calculatedAspectRatio: void 0,
+      naturalWidth: void 0,
+      hasError: !1
+    };
+  },
+  computed: {
+    computedAspectRatio() {
+      return Number(this.normalisedSrc.aspect || this.calculatedAspectRatio);
+    },
+    normalisedSrc() {
+      return this.src && typeof this.src == "object" ? {
+        src: this.src.src,
+        srcset: this.srcset || this.src.srcset,
+        lazySrc: this.lazySrc || this.src.lazySrc,
+        aspect: Number(this.aspectRatio || this.src.aspect)
+      } : {
+        src: this.src,
+        srcset: this.srcset,
+        lazySrc: this.lazySrc,
+        aspect: Number(this.aspectRatio || 0)
+      };
+    },
+    __cachedImage() {
+      if (!(this.normalisedSrc.src || this.normalisedSrc.lazySrc || this.gradient))
+        return [];
+      const t = [], e = this.isLoading ? this.normalisedSrc.lazySrc : this.currentSrc;
+      this.gradient && t.push(`linear-gradient(${this.gradient})`), e && t.push(`url("${e}")`);
+      const s = this.$createElement("div", {
+        staticClass: "v-image__image",
+        class: {
+          "v-image__image--preload": this.isLoading,
+          "v-image__image--contain": this.contain,
+          "v-image__image--cover": !this.contain
+        },
+        style: {
+          backgroundImage: t.join(", "),
+          backgroundPosition: this.position
+        },
+        key: +this.isLoading
+      });
+      return this.transition ? this.$createElement("transition", {
+        attrs: {
+          name: this.transition,
+          mode: "in-out"
+        }
+      }, [s]) : s;
+    }
+  },
+  watch: {
+    src() {
+      this.isLoading ? this.loadImage() : this.init(void 0, void 0, !0);
+    },
+    "$vuetify.breakpoint.width": "getSrc"
+  },
+  mounted() {
+    this.init();
+  },
+  methods: {
+    init(t, e, s) {
+      if (!(l && !s && !this.eager)) {
+        if (this.normalisedSrc.lazySrc) {
+          const i = new Image();
+          i.src = this.normalisedSrc.lazySrc, this.pollForSize(i, null);
+        }
+        this.normalisedSrc.src && this.loadImage();
+      }
+    },
+    onLoad() {
+      this.getSrc(), this.isLoading = !1, this.$emit("load", this.src), this.image && (this.normalisedSrc.src.endsWith(".svg") || this.normalisedSrc.src.startsWith("data:image/svg+xml")) && (this.image.naturalHeight && this.image.naturalWidth ? (this.naturalWidth = this.image.naturalWidth, this.calculatedAspectRatio = this.image.naturalWidth / this.image.naturalHeight) : this.calculatedAspectRatio = 1);
+    },
+    onError() {
+      this.hasError = !0, this.$emit("error", this.src);
+    },
+    getSrc() {
+      this.image && (this.currentSrc = this.image.currentSrc || this.image.src);
+    },
+    loadImage() {
+      const t = new Image();
+      this.image = t, t.onload = () => {
+        t.decode ? t.decode().catch((e) => {
+          f(`Failed to decode image, trying to render anyway
+
+src: ${this.normalisedSrc.src}` + (e.message ? `
+Original error: ${e.message}` : ""), this);
+        }).then(this.onLoad) : this.onLoad();
+      }, t.onerror = this.onError, this.hasError = !1, this.sizes && (t.sizes = this.sizes), this.normalisedSrc.srcset && (t.srcset = this.normalisedSrc.srcset), t.src = this.normalisedSrc.src, this.$emit("loadstart", this.normalisedSrc.src), this.aspectRatio || this.pollForSize(t), this.getSrc();
+    },
+    pollForSize(t, e = 100) {
+      const s = () => {
+        const {
+          naturalHeight: i,
+          naturalWidth: a
+        } = t;
+        i || a ? (this.naturalWidth = a, this.calculatedAspectRatio = a / i) : !t.complete && this.isLoading && !this.hasError && e != null && setTimeout(s, e);
+      };
+      s();
+    },
+    genContent() {
+      const t = o.options.methods.genContent.call(this);
+      return this.naturalWidth && this._b(t.data, "div", {
+        style: {
+          width: `${this.naturalWidth}px`
+        }
+      }), t;
+    },
+    __genPlaceholder() {
+      const t = n(this, "placeholder");
+      if (t) {
+        const e = this.isLoading ? [this.$createElement("div", {
+          staticClass: "v-image__placeholder"
+        }, t)] : [];
+        return this.transition ? this.$createElement("transition", {
+          props: {
+            appear: !0,
+            name: this.transition
+          }
+        }, e) : e[0];
+      }
+    }
+  },
+  render(t) {
+    const e = o.options.render.call(this, t), s = g(e.data, {
+      staticClass: "v-image",
+      attrs: {
+        "aria-label": this.alt,
+        role: this.alt ? "img" : void 0
+      },
+      class: this.themeClasses,
+      // Only load intersect directive if it
+      // will work in the current browser.
+      directives: l ? [{
+        name: "intersect",
+        modifiers: {
+          once: !0
+        },
+        value: {
+          handler: this.init,
+          options: this.options
+        }
+      }] : void 0
+    });
+    return e.children = [this.__cachedSizer, this.__cachedImage, this.__genPlaceholder(), this.genContent()], t(e.tag, s, e.children);
+  }
+}), C = c.extend({
+  name: "v-toolbar",
+  props: {
+    absolute: Boolean,
+    bottom: Boolean,
+    collapse: Boolean,
+    dense: Boolean,
+    extended: Boolean,
+    extensionHeight: {
+      default: 48,
+      type: [Number, String]
+    },
+    flat: Boolean,
+    floating: Boolean,
+    prominent: Boolean,
+    short: Boolean,
+    src: {
+      type: [String, Object],
+      default: ""
+    },
+    tag: {
+      type: String,
+      default: "header"
+    }
+  },
+  data: () => ({
+    isExtended: !1
+  }),
+  computed: {
+    computedHeight() {
+      const t = this.computedContentHeight;
+      if (!this.isExtended)
+        return t;
+      const e = parseInt(this.extensionHeight);
+      return this.isCollapsed ? t : t + (isNaN(e) ? 0 : e);
+    },
+    computedContentHeight() {
+      return this.height ? parseInt(this.height) : this.isProminent && this.dense ? 96 : this.isProminent && this.short ? 112 : this.isProminent ? 128 : this.dense ? 48 : this.short || this.$vuetify.breakpoint.smAndDown ? 56 : 64;
+    },
+    classes() {
+      return {
+        ...c.options.computed.classes.call(this),
+        "v-toolbar": !0,
+        "v-toolbar--absolute": this.absolute,
+        "v-toolbar--bottom": this.bottom,
+        "v-toolbar--collapse": this.collapse,
+        "v-toolbar--collapsed": this.isCollapsed,
+        "v-toolbar--dense": this.dense,
+        "v-toolbar--extended": this.isExtended,
+        "v-toolbar--flat": this.flat,
+        "v-toolbar--floating": this.floating,
+        "v-toolbar--prominent": this.isProminent
+      };
+    },
+    isCollapsed() {
+      return this.collapse;
+    },
+    isProminent() {
+      return this.prominent;
+    },
+    styles() {
+      return {
+        ...this.measurableStyles,
+        height: r(this.computedHeight)
+      };
+    }
+  },
+  created() {
+    [["app", "<v-app-bar app>"], ["manual-scroll", '<v-app-bar :value="false">'], ["clipped-left", "<v-app-bar clipped-left>"], ["clipped-right", "<v-app-bar clipped-right>"], ["inverted-scroll", "<v-app-bar inverted-scroll>"], ["scroll-off-screen", "<v-app-bar scroll-off-screen>"], ["scroll-target", "<v-app-bar scroll-target>"], ["scroll-threshold", "<v-app-bar scroll-threshold>"], ["card", "<v-app-bar flat>"]].forEach(([e, s]) => {
+      this.$attrs.hasOwnProperty(e) && S(e, s, this);
+    });
+  },
+  methods: {
+    genBackground() {
+      const t = {
+        height: r(this.computedHeight),
+        src: this.src
+      }, e = this.$scopedSlots.img ? this.$scopedSlots.img({
+        props: t
+      }) : this.$createElement(v, {
+        props: t
+      });
+      return this.$createElement("div", {
+        staticClass: "v-toolbar__image"
+      }, [e]);
+    },
+    genContent() {
+      return this.$createElement("div", {
+        staticClass: "v-toolbar__content",
+        style: {
+          height: r(this.computedContentHeight)
+        }
+      }, n(this));
+    },
+    genExtension() {
+      return this.$createElement("div", {
+        staticClass: "v-toolbar__extension",
+        style: {
+          height: r(this.extensionHeight)
+        }
+      }, n(this, "extension"));
+    }
+  },
+  render(t) {
+    this.isExtended = this.extended || !!this.$scopedSlots.extension;
+    const e = [this.genContent()], s = this.setBackgroundColor(this.color, {
+      class: this.classes,
+      style: this.styles,
+      on: this.$listeners
+    });
+    return this.isExtended && e.push(this.genExtension()), (this.src || this.$scopedSlots.img) && e.unshift(this.genBackground()), t(this.tag, s, e);
+  }
+});
+d("css/revolugo.vtoolbar.DQsezjcM.css");
+export {
+  C as _,
+  v as a
+};
+//# sourceMappingURL=revolugo.vtoolbar.D3HhuFrj.min.js.map

package/dist/revolugo.vtooltip.B7xN8tzo.min.js

@@ -0,0 +1,168 @@
+import { D as r, a as h, A as l } from "./revolugo.index.A8BtC3Nq.min.js";
+import { m as c, C as p } from "./revolugo.webcomponentwrapper.-wnE6sKX.min.js";
+import { M as d } from "./revolugo.index.CcRooNT6.min.js";
+import { h as n, o as u, p as f, k as m } from "./revolugo.revolugo-config.Bs_HF2Eu.min.js";
+function a(t) {
+  try {
+    if (typeof document < "u") {
+      window.REVOLUGO_ELEMENTS_STYLES = window.REVOLUGO_ELEMENTS_STYLES || {
+        sheets: [],
+        components: []
+      };
+      const e = import.meta.url, s = e.slice(0, e.lastIndexOf("/") + 1) + t;
+      window.REVOLUGO_ELEMENTS_STYLES.sheets.push(s);
+      for (const i of REVOLUGO_ELEMENTS_STYLES.components)
+        i(s);
+      if (t.indexOf("fonts") >= 0) {
+        const i = document.createElement("link");
+        i.rel = "stylesheet", linK.href = s, document.head.appendChild(i);
+      }
+    }
+  } catch (e) {
+    console.error("[revolugo-elements] ", e);
+  }
+}
+const T = c(p, h, r, d).extend({
+  name: "v-tooltip",
+  props: {
+    closeDelay: {
+      type: [Number, String],
+      default: 0
+    },
+    disabled: Boolean,
+    openDelay: {
+      type: [Number, String],
+      default: 0
+    },
+    openOnHover: {
+      type: Boolean,
+      default: !0
+    },
+    openOnFocus: {
+      type: Boolean,
+      default: !0
+    },
+    tag: {
+      type: String,
+      default: "span"
+    },
+    transition: String
+  },
+  data: () => ({
+    calculatedMinWidth: 0,
+    closeDependents: !1
+  }),
+  computed: {
+    calculatedLeft() {
+      const {
+        activator: t,
+        content: e
+      } = this.dimensions, s = !this.bottom && !this.left && !this.top && !this.right, i = this.attach !== !1 ? t.offsetLeft : t.left;
+      let o = 0;
+      return this.top || this.bottom || s ? o = i + t.width / 2 - e.width / 2 : (this.left || this.right) && (o = i + (this.right ? t.width : -e.width) + (this.right ? 10 : -10)), this.nudgeLeft && (o -= parseInt(this.nudgeLeft)), this.nudgeRight && (o += parseInt(this.nudgeRight)), `${this.calcXOverflow(o, this.dimensions.content.width)}px`;
+    },
+    calculatedTop() {
+      const {
+        activator: t,
+        content: e
+      } = this.dimensions, s = this.attach !== !1 ? t.offsetTop : t.top;
+      let i = 0;
+      return this.top || this.bottom ? i = s + (this.bottom ? t.height : -e.height) + (this.bottom ? 10 : -10) : (this.left || this.right) && (i = s + t.height / 2 - e.height / 2), this.nudgeTop && (i -= parseInt(this.nudgeTop)), this.nudgeBottom && (i += parseInt(this.nudgeBottom)), this.attach === !1 && (i += this.pageYOffset), `${this.calcYOverflow(i)}px`;
+    },
+    classes() {
+      return {
+        "v-tooltip--top": this.top,
+        "v-tooltip--right": this.right,
+        "v-tooltip--bottom": this.bottom,
+        "v-tooltip--left": this.left,
+        "v-tooltip--attached": this.attach === "" || this.attach === !0 || this.attach === "attach"
+      };
+    },
+    computedTransition() {
+      return this.transition ? this.transition : this.isActive ? "scale-transition" : "fade-transition";
+    },
+    offsetY() {
+      return this.top || this.bottom;
+    },
+    offsetX() {
+      return this.left || this.right;
+    },
+    styles() {
+      return {
+        left: this.calculatedLeft,
+        maxWidth: n(this.maxWidth),
+        minWidth: n(this.minWidth),
+        top: this.calculatedTop,
+        zIndex: this.zIndex || this.activeZIndex
+      };
+    }
+  },
+  beforeMount() {
+    this.$nextTick(() => {
+      this.value && this.callActivate();
+    });
+  },
+  mounted() {
+    u(this, "activator", !0) === "v-slot" && f(`v-tooltip's activator slot must be bound, try '<template #activator="data"><v-btn v-on="data.on>'`, this);
+  },
+  methods: {
+    activate() {
+      this.updateDimensions(), requestAnimationFrame(this.startTransition);
+    },
+    deactivate() {
+      this.runDelay("close");
+    },
+    genActivatorListeners() {
+      const t = l.options.methods.genActivatorListeners.call(this);
+      return this.openOnFocus && (t.focus = (e) => {
+        this.getActivator(e), this.runDelay("open");
+      }, t.blur = (e) => {
+        this.getActivator(e), this.runDelay("close");
+      }), t.keydown = (e) => {
+        e.keyCode === m.esc && (this.getActivator(e), this.runDelay("close"));
+      }, t;
+    },
+    genActivatorAttributes() {
+      return {
+        "aria-haspopup": !0,
+        "aria-expanded": String(this.isActive)
+      };
+    },
+    genTransition() {
+      const t = this.genContent();
+      return this.computedTransition ? this.$createElement("transition", {
+        props: {
+          name: this.computedTransition
+        }
+      }, [t]) : t;
+    },
+    genContent() {
+      return this.$createElement("div", this.setBackgroundColor(this.color, {
+        staticClass: "v-tooltip__content",
+        class: {
+          [this.contentClass]: !0,
+          menuable__content__active: this.isActive,
+          "v-tooltip__content--fixed": this.activatorFixed
+        },
+        style: this.styles,
+        attrs: this.getScopeIdAttrs(),
+        directives: [{
+          name: "show",
+          value: this.isContentActive
+        }],
+        ref: "content"
+      }), this.getContentSlot());
+    }
+  },
+  render(t) {
+    return t(this.tag, {
+      staticClass: "v-tooltip",
+      class: this.classes
+    }, [this.showLazyContent(() => [this.genTransition()]), this.genActivator()]);
+  }
+});
+a("css/revolugo.vtooltip.B_oOB9pj.css");
+export {
+  T as _
+};
+//# sourceMappingURL=revolugo.vtooltip.B7xN8tzo.min.js.map