@revolugo/elements 5.5.4 → 5.5.5-beta.0

package/dist/revolugo.vslidegroup.BXF0FLd1.min.js

@@ -0,0 +1,650 @@
+import { T as c, R as g } from "./revolugo.vuetify.yojzDMFk.min.js";
+import { _ as x } from "./revolugo.vbtn.CP4AezmI.min.js";
+import { _ as p, f as $ } from "./revolugo.index.sTY3URQu.min.js";
+import { B as l } from "./revolugo.vitemgroup.DyY_3pfW.min.js";
+import { B as y } from "./revolugo.watch-list.cR2ZEwBA.min.js";
+import { n as b, h as f, z as T } from "./revolugo.revolugo-config.Bs_HF2Eu.min.js";
+import { m as v } from "./revolugo.webcomponentwrapper.-wnE6sKX.min.js";
+import { b as _ } from "./revolugo.index.Cn8GgIte.min.js";
+import { V as I } from "./revolugo.i18n.DF3U6VhD.min.js";
+function w(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 = I.extend({
+  name: "mobile",
+  props: {
+    mobileBreakpoint: {
+      type: [Number, String],
+      default() {
+        return this.$vuetify ? this.$vuetify.breakpoint.mobileBreakpoint : void 0;
+      },
+      validator: (t) => !isNaN(Number(t)) || ["xs", "sm", "md", "lg", "xl"].includes(String(t))
+    }
+  },
+  computed: {
+    isMobile() {
+      const {
+        mobile: t,
+        width: e,
+        name: s,
+        mobileBreakpoint: i
+      } = this.$vuetify.breakpoint;
+      if (i === this.mobileBreakpoint)
+        return t;
+      const n = parseInt(this.mobileBreakpoint, 10);
+      return !isNaN(n) ? e < n : s === this.mobileBreakpoint;
+    }
+  },
+  created() {
+    this.$attrs.hasOwnProperty("mobile-break-point") && b("mobile-break-point", "mobile-breakpoint", this);
+  }
+}), G = l.extend({
+  name: "v-window",
+  directives: {
+    Touch: c
+  },
+  provide() {
+    return {
+      windowGroup: this
+    };
+  },
+  props: {
+    activeClass: {
+      type: String,
+      default: "v-window-item--active"
+    },
+    continuous: Boolean,
+    mandatory: {
+      type: Boolean,
+      default: !0
+    },
+    nextIcon: {
+      type: [Boolean, String],
+      default: "$next"
+    },
+    prevIcon: {
+      type: [Boolean, String],
+      default: "$prev"
+    },
+    reverse: Boolean,
+    showArrows: Boolean,
+    showArrowsOnHover: Boolean,
+    touch: Object,
+    touchless: Boolean,
+    value: {
+      required: !1
+    },
+    vertical: Boolean
+  },
+  data() {
+    return {
+      changedByDelimiters: !1,
+      internalHeight: void 0,
+      transitionHeight: void 0,
+      transitionCount: 0,
+      isBooted: !1,
+      isReverse: !1
+    };
+  },
+  computed: {
+    isActive() {
+      return this.transitionCount > 0;
+    },
+    classes() {
+      return {
+        ...l.options.computed.classes.call(this),
+        "v-window--show-arrows-on-hover": this.showArrowsOnHover
+      };
+    },
+    computedTransition() {
+      if (!this.isBooted)
+        return "";
+      const t = this.vertical ? "y" : "x", s = (this.internalReverse ? !this.isReverse : this.isReverse) ? "-reverse" : "";
+      return `v-window-${t}${s}-transition`;
+    },
+    hasActiveItems() {
+      return !!this.items.find((t) => !t.disabled);
+    },
+    hasNext() {
+      return this.continuous || this.internalIndex < this.items.length - 1;
+    },
+    hasPrev() {
+      return this.continuous || this.internalIndex > 0;
+    },
+    internalIndex() {
+      return this.items.findIndex((t, e) => this.internalValue === this.getValue(t, e));
+    },
+    internalReverse() {
+      return this.$vuetify.rtl ? !this.reverse : this.reverse;
+    }
+  },
+  watch: {
+    internalIndex(t, e) {
+      this.isReverse = this.updateReverse(t, e);
+    }
+  },
+  mounted() {
+    window.requestAnimationFrame(() => this.isBooted = !0);
+  },
+  methods: {
+    genDefaultSlot() {
+      return this.$slots.default;
+    },
+    genContainer() {
+      const t = [this.genDefaultSlot()];
+      return this.showArrows && t.push(this.genControlIcons()), this.$createElement("div", {
+        staticClass: "v-window__container",
+        class: {
+          "v-window__container--is-active": this.isActive
+        },
+        style: {
+          height: this.internalHeight || this.transitionHeight
+        }
+      }, t);
+    },
+    genIcon(t, e, s) {
+      var i, n, r;
+      const o = {
+        click: (m) => {
+          m.stopPropagation(), this.changedByDelimiters = !0, s();
+        }
+      }, h = {
+        "aria-label": this.$vuetify.lang.t(`$vuetify.carousel.${t}`)
+      }, a = (r = (n = (i = this.$scopedSlots)[t]) === null || n === void 0 ? void 0 : n.call(i, {
+        on: o,
+        attrs: h
+      })) !== null && r !== void 0 ? r : [this.$createElement(x, {
+        props: {
+          icon: !0
+        },
+        attrs: h,
+        on: o
+      }, [this.$createElement(p, {
+        props: {
+          large: !0
+        }
+      }, e)])];
+      return this.$createElement("div", {
+        staticClass: `v-window__${t}`
+      }, a);
+    },
+    genControlIcons() {
+      const t = [], e = this.$vuetify.rtl ? this.nextIcon : this.prevIcon;
+      if (this.hasPrev && e && typeof e == "string") {
+        const i = this.genIcon("prev", e, this.prev);
+        i && t.push(i);
+      }
+      const s = this.$vuetify.rtl ? this.prevIcon : this.nextIcon;
+      if (this.hasNext && s && typeof s == "string") {
+        const i = this.genIcon("next", s, this.next);
+        i && t.push(i);
+      }
+      return t;
+    },
+    getNextIndex(t) {
+      const e = (t + 1) % this.items.length;
+      return this.items[e].disabled ? this.getNextIndex(e) : e;
+    },
+    getPrevIndex(t) {
+      const e = (t + this.items.length - 1) % this.items.length;
+      return this.items[e].disabled ? this.getPrevIndex(e) : e;
+    },
+    next() {
+      if (!this.hasActiveItems || !this.hasNext)
+        return;
+      const t = this.getNextIndex(this.internalIndex), e = this.items[t];
+      this.internalValue = this.getValue(e, t);
+    },
+    prev() {
+      if (!this.hasActiveItems || !this.hasPrev)
+        return;
+      const t = this.getPrevIndex(this.internalIndex), e = this.items[t];
+      this.internalValue = this.getValue(e, t);
+    },
+    updateReverse(t, e) {
+      const s = this.items.length, i = s - 1;
+      return s <= 2 ? t < e : t === i && e === 0 ? !0 : t === 0 && e === i ? !1 : t < e;
+    }
+  },
+  render(t) {
+    const e = {
+      staticClass: "v-window",
+      class: this.classes,
+      directives: []
+    };
+    if (!this.touchless) {
+      const s = this.touch || {
+        left: () => {
+          this.$vuetify.rtl ? this.prev() : this.next();
+        },
+        right: () => {
+          this.$vuetify.rtl ? this.next() : this.prev();
+        },
+        end: (i) => {
+          i.stopPropagation();
+        },
+        start: (i) => {
+          i.stopPropagation();
+        }
+      };
+      e.directives.push({
+        name: "touch",
+        value: s
+      });
+    }
+    return t("div", e, [this.genContainer()]);
+  }
+}), C = v(y, $("windowGroup", "v-window-item", "v-window")), V = C.extend().extend().extend({
+  name: "v-window-item",
+  directives: {
+    Touch: c
+  },
+  props: {
+    disabled: Boolean,
+    reverseTransition: {
+      type: [Boolean, String],
+      default: void 0
+    },
+    transition: {
+      type: [Boolean, String],
+      default: void 0
+    },
+    value: {
+      required: !1
+    }
+  },
+  data() {
+    return {
+      isActive: !1,
+      inTransition: !1
+    };
+  },
+  computed: {
+    classes() {
+      return this.groupClasses;
+    },
+    computedTransition() {
+      return this.windowGroup.internalReverse ? typeof this.reverseTransition < "u" ? this.reverseTransition || "" : this.windowGroup.computedTransition : typeof this.transition < "u" ? this.transition || "" : this.windowGroup.computedTransition;
+    }
+  },
+  methods: {
+    genDefaultSlot() {
+      return this.$slots.default;
+    },
+    genWindowItem() {
+      return this.$createElement("div", {
+        staticClass: "v-window-item",
+        class: this.classes,
+        directives: [{
+          name: "show",
+          value: this.isActive
+        }],
+        on: this.$listeners
+      }, this.genDefaultSlot());
+    },
+    onAfterTransition() {
+      this.inTransition && (this.inTransition = !1, this.windowGroup.transitionCount > 0 && (this.windowGroup.transitionCount--, this.windowGroup.transitionCount === 0 && (this.windowGroup.transitionHeight = void 0)));
+    },
+    onBeforeTransition() {
+      this.inTransition || (this.inTransition = !0, this.windowGroup.transitionCount === 0 && (this.windowGroup.transitionHeight = f(this.windowGroup.$el.clientHeight)), this.windowGroup.transitionCount++);
+    },
+    onTransitionCancelled() {
+      this.onAfterTransition();
+    },
+    onEnter(t) {
+      this.inTransition && this.$nextTick(() => {
+        !this.computedTransition || !this.inTransition || (this.windowGroup.transitionHeight = f(t.clientHeight));
+      });
+    }
+  },
+  render(t) {
+    return t("transition", {
+      props: {
+        name: this.computedTransition
+      },
+      on: {
+        // Handlers for enter windows.
+        beforeEnter: this.onBeforeTransition,
+        afterEnter: this.onAfterTransition,
+        enterCancelled: this.onTransitionCancelled,
+        // Handlers for leave windows.
+        beforeLeave: this.onBeforeTransition,
+        afterLeave: this.onAfterTransition,
+        leaveCancelled: this.onTransitionCancelled,
+        // Enter handler for height transition.
+        enter: this.onEnter
+      }
+    }, this.showLazyContent(() => [this.genWindowItem()]));
+  }
+});
+function u(t) {
+  const s = Math.abs(t);
+  return Math.sign(t) * (s / ((1 / 0.501 - 2) * (1 - s) + 1));
+}
+function d(t, e, s, i) {
+  const n = t.clientWidth, r = s ? e.content - t.offsetLeft - n : t.offsetLeft;
+  s && (i = -i);
+  const o = e.wrapper + i, h = n + r, a = n * 0.4;
+  return r <= i ? i = Math.max(r - a, 0) : o <= h && (i = Math.min(i - (o - h - a), e.content - e.wrapper)), s ? -i : i;
+}
+function E(t, e, s) {
+  const {
+    offsetLeft: i,
+    clientWidth: n
+  } = t;
+  if (s) {
+    const r = e.content - i - n / 2 - e.wrapper / 2;
+    return -Math.min(e.content - e.wrapper, Math.max(0, r));
+  } else {
+    const r = i + n / 2 - e.wrapper / 2;
+    return Math.min(e.content - e.wrapper, Math.max(0, r));
+  }
+}
+const S = v(l, O).extend({
+  name: "base-slide-group",
+  directives: {
+    Resize: g,
+    Touch: c
+  },
+  props: {
+    activeClass: {
+      type: String,
+      default: "v-slide-item--active"
+    },
+    centerActive: Boolean,
+    nextIcon: {
+      type: String,
+      default: "$next"
+    },
+    prevIcon: {
+      type: String,
+      default: "$prev"
+    },
+    showArrows: {
+      type: [Boolean, String],
+      validator: (t) => typeof t == "boolean" || ["always", "never", "desktop", "mobile"].includes(t)
+    }
+  },
+  data: () => ({
+    isOverflowing: !1,
+    resizeTimeout: 0,
+    startX: 0,
+    isSwipingHorizontal: !1,
+    isSwiping: !1,
+    scrollOffset: 0,
+    widths: {
+      content: 0,
+      wrapper: 0
+    }
+  }),
+  computed: {
+    canTouch() {
+      return typeof window < "u";
+    },
+    __cachedNext() {
+      return this.genTransition("next");
+    },
+    __cachedPrev() {
+      return this.genTransition("prev");
+    },
+    classes() {
+      return {
+        ...l.options.computed.classes.call(this),
+        "v-slide-group": !0,
+        "v-slide-group--has-affixes": this.hasAffixes,
+        "v-slide-group--is-overflowing": this.isOverflowing
+      };
+    },
+    hasAffixes() {
+      switch (this.showArrows) {
+        case "always":
+          return !0;
+        case "desktop":
+          return !this.isMobile;
+        case !0:
+          return this.isOverflowing || Math.abs(this.scrollOffset) > 0;
+        case "mobile":
+          return this.isMobile || this.isOverflowing || Math.abs(this.scrollOffset) > 0;
+        case "never":
+          return !1;
+        default:
+          return !this.isMobile && (this.isOverflowing || Math.abs(this.scrollOffset) > 0);
+      }
+    },
+    hasNext() {
+      if (!this.hasAffixes)
+        return !1;
+      const {
+        content: t,
+        wrapper: e
+      } = this.widths;
+      return t > Math.abs(this.scrollOffset) + e;
+    },
+    hasPrev() {
+      return this.hasAffixes && this.scrollOffset !== 0;
+    }
+  },
+  watch: {
+    internalValue: "setWidths",
+    // When overflow changes, the arrows alter
+    // the widths of the content and wrapper
+    // and need to be recalculated
+    isOverflowing: "setWidths",
+    scrollOffset(t) {
+      this.$vuetify.rtl && (t = -t);
+      let e = t <= 0 ? u(-t) : t > this.widths.content - this.widths.wrapper ? -(this.widths.content - this.widths.wrapper) + u(this.widths.content - this.widths.wrapper - t) : -t;
+      this.$vuetify.rtl && (e = -e), this.$refs.content.style.transform = `translateX(${e}px)`;
+    }
+  },
+  mounted() {
+    if (typeof ResizeObserver < "u") {
+      const t = new ResizeObserver(() => {
+        this.onResize();
+      });
+      t.observe(this.$el), t.observe(this.$refs.content), this.$on("hook:destroyed", () => {
+        t.disconnect();
+      });
+    } else {
+      let t = 0;
+      this.$on("hook:beforeUpdate", () => {
+        var e;
+        t = (((e = this.$refs.content) === null || e === void 0 ? void 0 : e.children) || []).length;
+      }), this.$on("hook:updated", () => {
+        var e;
+        t !== (((e = this.$refs.content) === null || e === void 0 ? void 0 : e.children) || []).length && this.setWidths();
+      });
+    }
+  },
+  methods: {
+    onScroll() {
+      this.$refs.wrapper.scrollLeft = 0;
+    },
+    onFocusin(t) {
+      if (this.isOverflowing) {
+        for (const e of T(t))
+          for (const s of this.items)
+            if (s.$el === e) {
+              this.scrollOffset = d(s.$el, this.widths, this.$vuetify.rtl, this.scrollOffset);
+              return;
+            }
+      }
+    },
+    // Always generate next for scrollable hint
+    genNext() {
+      const t = this.$scopedSlots.next ? this.$scopedSlots.next({}) : this.$slots.next || this.__cachedNext;
+      return this.$createElement("div", {
+        staticClass: "v-slide-group__next",
+        class: {
+          "v-slide-group__next--disabled": !this.hasNext
+        },
+        on: {
+          click: () => this.onAffixClick("next")
+        },
+        key: "next"
+      }, [t]);
+    },
+    genContent() {
+      return this.$createElement("div", {
+        staticClass: "v-slide-group__content",
+        ref: "content",
+        on: {
+          focusin: this.onFocusin
+        }
+      }, this.$slots.default);
+    },
+    genData() {
+      return {
+        class: this.classes,
+        directives: [{
+          name: "resize",
+          value: this.onResize
+        }]
+      };
+    },
+    genIcon(t) {
+      let e = t;
+      this.$vuetify.rtl && t === "prev" ? e = "next" : this.$vuetify.rtl && t === "next" && (e = "prev");
+      const s = `${t[0].toUpperCase()}${t.slice(1)}`, i = this[`has${s}`];
+      return !this.showArrows && !i ? null : this.$createElement(p, {
+        props: {
+          disabled: !i
+        }
+      }, this[`${e}Icon`]);
+    },
+    // Always generate prev for scrollable hint
+    genPrev() {
+      const t = this.$scopedSlots.prev ? this.$scopedSlots.prev({}) : this.$slots.prev || this.__cachedPrev;
+      return this.$createElement("div", {
+        staticClass: "v-slide-group__prev",
+        class: {
+          "v-slide-group__prev--disabled": !this.hasPrev
+        },
+        on: {
+          click: () => this.onAffixClick("prev")
+        },
+        key: "prev"
+      }, [t]);
+    },
+    genTransition(t) {
+      return this.$createElement(_, [this.genIcon(t)]);
+    },
+    genWrapper() {
+      return this.$createElement("div", {
+        staticClass: "v-slide-group__wrapper",
+        directives: [{
+          name: "touch",
+          value: {
+            start: (t) => this.overflowCheck(t, this.onTouchStart),
+            move: (t) => this.overflowCheck(t, this.onTouchMove),
+            end: (t) => this.overflowCheck(t, this.onTouchEnd)
+          }
+        }],
+        ref: "wrapper",
+        on: {
+          scroll: this.onScroll
+        }
+      }, [this.genContent()]);
+    },
+    calculateNewOffset(t, e, s, i) {
+      const n = s ? -1 : 1, r = n * i + (t === "prev" ? -1 : 1) * e.wrapper;
+      return n * Math.max(Math.min(r, e.content - e.wrapper), 0);
+    },
+    onAffixClick(t) {
+      this.$emit(`click:${t}`), this.scrollTo(t);
+    },
+    onResize() {
+      this._isDestroyed || this.setWidths();
+    },
+    onTouchStart(t) {
+      const {
+        content: e
+      } = this.$refs;
+      this.startX = this.scrollOffset + t.touchstartX, e.style.setProperty("transition", "none"), e.style.setProperty("willChange", "transform");
+    },
+    onTouchMove(t) {
+      if (this.canTouch) {
+        if (!this.isSwiping) {
+          const e = t.touchmoveX - t.touchstartX, s = t.touchmoveY - t.touchstartY;
+          this.isSwipingHorizontal = Math.abs(e) > Math.abs(s), this.isSwiping = !0;
+        }
+        this.isSwipingHorizontal && (this.scrollOffset = this.startX - t.touchmoveX, document.documentElement.style.overflowY = "hidden");
+      }
+    },
+    onTouchEnd() {
+      if (!this.canTouch)
+        return;
+      const {
+        content: t,
+        wrapper: e
+      } = this.$refs, s = t.clientWidth - e.clientWidth;
+      t.style.setProperty("transition", null), t.style.setProperty("willChange", null), this.$vuetify.rtl ? this.scrollOffset > 0 || !this.isOverflowing ? this.scrollOffset = 0 : this.scrollOffset <= -s && (this.scrollOffset = -s) : this.scrollOffset < 0 || !this.isOverflowing ? this.scrollOffset = 0 : this.scrollOffset >= s && (this.scrollOffset = s), this.isSwiping = !1, document.documentElement.style.removeProperty("overflow-y");
+    },
+    overflowCheck(t, e) {
+      t.stopPropagation(), this.isOverflowing && e(t);
+    },
+    scrollIntoView() {
+      if (!this.selectedItem && this.items.length) {
+        const t = this.items[this.items.length - 1].$el.getBoundingClientRect(), e = this.$refs.wrapper.getBoundingClientRect();
+        (this.$vuetify.rtl && e.right < t.right || !this.$vuetify.rtl && e.left > t.left) && this.scrollTo("prev");
+      }
+      this.selectedItem && (this.selectedIndex === 0 || !this.centerActive && !this.isOverflowing ? this.scrollOffset = 0 : this.centerActive ? this.scrollOffset = E(this.selectedItem.$el, this.widths, this.$vuetify.rtl) : this.isOverflowing && (this.scrollOffset = d(this.selectedItem.$el, this.widths, this.$vuetify.rtl, this.scrollOffset)));
+    },
+    scrollTo(t) {
+      this.scrollOffset = this.calculateNewOffset(t, {
+        // Force reflow
+        content: this.$refs.content ? this.$refs.content.clientWidth : 0,
+        wrapper: this.$refs.wrapper ? this.$refs.wrapper.clientWidth : 0
+      }, this.$vuetify.rtl, this.scrollOffset);
+    },
+    setWidths() {
+      window.requestAnimationFrame(() => {
+        if (this._isDestroyed)
+          return;
+        const {
+          content: t,
+          wrapper: e
+        } = this.$refs;
+        this.widths = {
+          content: t ? t.clientWidth : 0,
+          wrapper: e ? e.clientWidth : 0
+        }, this.isOverflowing = this.widths.wrapper + 1 < this.widths.content, this.scrollIntoView();
+      });
+    }
+  },
+  render(t) {
+    return t("div", this.genData(), [this.genPrev(), this.genWrapper(), this.genNext()]);
+  }
+}), H = S.extend({
+  name: "v-slide-group",
+  provide() {
+    return {
+      slideGroup: this
+    };
+  }
+});
+w("css/revolugo.vslidegroup.D5TIbmaw.css");
+export {
+  S as B,
+  O as M,
+  G as V,
+  H as _,
+  V as a
+};
+//# sourceMappingURL=revolugo.vslidegroup.BXF0FLd1.min.js.map