maz-ui 4.0.0-alpha.5 → 4.0.0-beta.1

package/dist/components/MazAnimatedCounter.js

@@ -0,0 +1,77 @@
+import { defineComponent, ref, onMounted, onBeforeUnmount, watch, createElementBlock, openBlock, createElementVNode, renderSlot, createTextVNode, toDisplayString } from "vue";
+import { i as isClient } from "../chunks/isClient.WI4oSt66.js";
+import { _ as _export_sfc } from "../chunks/_plugin-vue_export-helper.B--vMWp3.js";
+import '../assets/MazAnimatedCounter.CTG-PC5W.css';const _hoisted_1 = { class: "maz-sr-only" }, _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "MazAnimatedCounter",
+  props: {
+    count: {},
+    duration: { default: 1e3 },
+    prefix: { default: void 0 },
+    suffix: { default: void 0 },
+    delay: { default: 100 },
+    once: { type: Boolean, default: !0 }
+  },
+  setup(__props) {
+    const props = __props, currentCount = ref(0), elementRef = ref(null);
+    function getRequestAnimationFrame() {
+      return !isClient() || !window.requestAnimationFrame ? (callback) => (setTimeout(callback, 1e3 / 60), 0) : window.requestAnimationFrame.bind(window);
+    }
+    function animate(start, end, duration, delay) {
+      const requestAnim = getRequestAnimationFrame();
+      if (!isClient()) {
+        currentCount.value = end;
+        return;
+      }
+      currentCount.value = start, setTimeout(() => {
+        const startTime = performance.now(), updateCount = (currentTime = performance.now()) => {
+          const elapsed = currentTime - startTime, progress = Math.min(elapsed / duration, 1), easeOutQuad = (t) => t * (2 - t);
+          currentCount.value = Math.round(
+            start + (end - start) * easeOutQuad(progress)
+          ), progress < 1 && requestAnim(updateCount);
+        };
+        requestAnim(updateCount);
+      }, delay);
+    }
+    function startAnimation(start, end) {
+      animate(start, end, props.duration, props.delay);
+    }
+    let observer = null;
+    return onMounted(() => {
+      props.once || (observer = new IntersectionObserver(([entry]) => {
+        entry.isIntersecting && (startAnimation(0, props.count), props.once && observer?.unobserve(entry.target));
+      }), elementRef.value && observer.observe(elementRef.value));
+    }), onBeforeUnmount(() => observer?.disconnect()), watch(
+      () => props.count,
+      (newCount, oldCount) => {
+        if (newCount === oldCount)
+          return;
+        startAnimation(oldCount ?? 0, newCount);
+      },
+      { immediate: !0 }
+    ), (_ctx, _cache) => (openBlock(), createElementBlock("span", {
+      ref_key: "elementRef",
+      ref: elementRef,
+      class: "m-animated-counter m-reset-css"
+    }, [
+      createElementVNode("span", _hoisted_1, [
+        renderSlot(_ctx.$slots, "prefix", {}, () => [
+          createTextVNode(toDisplayString(_ctx.prefix), 1)
+        ], !0),
+        createTextVNode(toDisplayString(_ctx.count), 1),
+        renderSlot(_ctx.$slots, "suffix", {}, () => [
+          createTextVNode(toDisplayString(_ctx.suffix), 1)
+        ], !0)
+      ]),
+      renderSlot(_ctx.$slots, "prefix", {}, () => [
+        createTextVNode(toDisplayString(_ctx.prefix), 1)
+      ], !0),
+      createTextVNode(toDisplayString(currentCount.value), 1),
+      renderSlot(_ctx.$slots, "suffix", {}, () => [
+        createTextVNode(toDisplayString(_ctx.suffix), 1)
+      ], !0)
+    ], 512));
+  }
+}), MazAnimatedCounter = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-59b16e46"]]);
+export {
+  MazAnimatedCounter as default
+};

package/dist/components/MazAnimatedElement.js

@@ -0,0 +1,33 @@
+import { defineComponent, computed, ref, onMounted, onBeforeUnmount, createElementBlock, openBlock, normalizeStyle, renderSlot } from "vue";
+import { _ as _export_sfc } from "../chunks/_plugin-vue_export-helper.B--vMWp3.js";
+import '../assets/MazAnimatedElement.B4mV3dWm.css';const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "MazAnimatedElement",
+  props: {
+    direction: { default: "up" },
+    delay: { default: 0 },
+    duration: { default: 2e3 },
+    once: { type: Boolean, default: !0 }
+  },
+  setup(__props) {
+    const animatedClass = computed(() => `animate-slide-${__props.direction}-blur`), element = ref();
+    let observer = null;
+    return onMounted(() => {
+      observer = new IntersectionObserver(([entry]) => {
+        entry.isIntersecting ? (entry.target.classList.remove("--invisible"), entry.target.classList.add(animatedClass.value), __props.once === !0 && observer?.unobserve(entry.target)) : __props.once === !1 && (entry.target.classList.add("--invisible"), entry.target.classList.remove(animatedClass.value));
+      }), element.value && observer.observe(element.value);
+    }), onBeforeUnmount(() => observer?.disconnect()), (_ctx, _cache) => (openBlock(), createElementBlock("div", {
+      ref_key: "element",
+      ref: element,
+      class: "m-animated-element m-reset-css --invisible",
+      style: normalizeStyle({
+        animationDuration: `${_ctx.duration}ms`,
+        animationDelay: `${_ctx.delay}ms`
+      })
+    }, [
+      renderSlot(_ctx.$slots, "default", {}, void 0, !0)
+    ], 4));
+  }
+}), MazAnimatedElement = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-c463d914"]]);
+export {
+  MazAnimatedElement as default
+};

package/dist/components/MazAnimatedText.js

@@ -0,0 +1,79 @@
+import { defineComponent, computed, ref, onMounted, onBeforeUnmount, createElementBlock, openBlock, createBlock, resolveDynamicComponent, mergeProps, withCtx, createCommentVNode, Fragment, renderList, createElementVNode, normalizeStyle, normalizeClass, toDisplayString, createTextVNode } from "vue";
+import { c as checkAvailability } from "../chunks/checkAvailability.aTpZidex.js";
+import { _ as _export_sfc } from "../chunks/_plugin-vue_export-helper.B--vMWp3.js";
+import '../assets/MazAnimatedText.BrOwWuqf.css';const _hoisted_1 = { class: "m-reset-css m-animated-text" }, _hoisted_2 = { class: "m-animated-text__last-word-inner" }, _hoisted_3 = { class: "m-animated-text__last-word-inner-text" }, _sfc_main = /* @__PURE__ */ defineComponent({
+  inheritAttrs: !1,
+  __name: "MazAnimatedText",
+  props: {
+    text: {},
+    lastWord: {},
+    delay: { default: 0 },
+    direction: { default: "up" },
+    tag: { default: "span" },
+    wordDelay: { default: 75 },
+    columnGap: { default: 0.5 },
+    rowGap: { default: 0 },
+    duration: { default: 2e3 },
+    once: { type: Boolean, default: !0 }
+  },
+  setup(__props) {
+    const words = computed(() => __props.text.split(" ")), wordCount = computed(() => words.value.length), isVisible = ref(!1), isClient = ref(!1), animatedClass = computed(() => isVisible.value ? `maz-animate-slide-${__props.direction}-blur` : "maz-invisible"), element = ref();
+    let observer = null;
+    return onMounted(() => {
+      isClient.value = !0, observer = new IntersectionObserver(([entry]) => {
+        isVisible.value = entry.isIntersecting, __props.once && element.value && observer?.unobserve(element.value);
+      }), checkAvailability(() => element.value, (element2) => {
+        observer?.observe(element2);
+      });
+    }), onBeforeUnmount(() => observer?.disconnect()), (_ctx, _cache) => (openBlock(), createElementBlock("div", _hoisted_1, [
+      isClient.value ? (openBlock(), createBlock(resolveDynamicComponent(_ctx.tag), mergeProps({
+        key: 0,
+        ref_key: "element",
+        ref: element
+      }, _ctx.$attrs, {
+        class: "m-animated-text__root",
+        style: { columnGap: `${_ctx.columnGap}rem`, rowGap: `${_ctx.rowGap}rem` }
+      }), {
+        default: withCtx(() => [
+          (openBlock(!0), createElementBlock(Fragment, null, renderList(words.value, (word, index) => (openBlock(), createElementBlock("span", {
+            key: word + index,
+            class: "m-animated-text__word"
+          }, [
+            createElementVNode("span", {
+              class: normalizeClass(["m-animated-text__word-inner", animatedClass.value]),
+              style: normalizeStyle({
+                animationDelay: `${_ctx.delay + index * (_ctx.wordDelay ?? 150)}ms`,
+                animationDuration: `${_ctx.duration}ms`
+              })
+            }, toDisplayString(word), 7)
+          ]))), 128)),
+          _ctx.lastWord ? (openBlock(), createElementBlock("span", {
+            key: 0,
+            class: normalizeClass(["m-animated-text__last-word", animatedClass.value]),
+            style: normalizeStyle({
+              animationDelay: `${_ctx.delay + wordCount.value * (_ctx.wordDelay ?? 150)}ms`,
+              animationDuration: `${_ctx.duration}ms`
+            })
+          }, [
+            createElementVNode("span", _hoisted_2, [
+              _cache[0] || (_cache[0] = createElementVNode("span", { class: "m-animated-text__last-word-inner-gradient" }, null, -1)),
+              createElementVNode("span", _hoisted_3, toDisplayString(_ctx.lastWord), 1)
+            ])
+          ], 6)) : createCommentVNode("", !0)
+        ]),
+        _: 1
+      }, 16, ["style"])) : (openBlock(), createBlock(resolveDynamicComponent(_ctx.tag), mergeProps({ key: 1 }, _ctx.$attrs, { class: "maz-invisible maz-inline-flex" }), {
+        default: withCtx(() => [
+          createTextVNode(toDisplayString(_ctx.text) + " ", 1),
+          _ctx.lastWord ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
+            createTextVNode(toDisplayString(_ctx.lastWord), 1)
+          ], 64)) : createCommentVNode("", !0)
+        ]),
+        _: 1
+      }, 16))
+    ]));
+  }
+}), MazAnimatedText = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-195e3ada"]]);
+export {
+  MazAnimatedText as default
+};

package/dist/components/MazAvatar.js

@@ -0,0 +1,123 @@
+import { defineComponent, defineAsyncComponent, computed, createBlock, openBlock, resolveDynamicComponent, normalizeClass, normalizeStyle, withCtx, createElementVNode, renderSlot, createElementBlock, createCommentVNode, Fragment, unref, mergeProps, toDisplayString, createVNode } from "vue";
+import { MazPencil } from "@maz-ui/icons";
+import { _ as _export_sfc } from "../chunks/_plugin-vue_export-helper.B--vMWp3.js";
+import '../assets/MazAvatar.DaDlvfYd.css';const _hoisted_1 = ["tabindex"], _hoisted_2 = ["src", "alt", "loading"], _hoisted_3 = { class: "m-avatar__initial" }, _hoisted_4 = {
+  key: 0,
+  class: "m-avatar__caption"
+}, _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "MazAvatar",
+  props: {
+    style: {},
+    class: {},
+    src: { default: void 0 },
+    caption: { default: void 0 },
+    href: { default: void 0 },
+    to: { default: void 0 },
+    alt: { default: "avatar image" },
+    target: { default: "_self" },
+    size: { default: void 0 },
+    bordered: { type: Boolean },
+    clickable: { type: Boolean },
+    square: { type: Boolean },
+    noElevation: { type: Boolean },
+    showCaption: { type: Boolean },
+    imageHeightFull: { type: Boolean },
+    hideLoader: { type: Boolean },
+    buttonColor: { default: "info" },
+    hideClickableIcon: { type: Boolean },
+    letterCount: { default: void 0 },
+    roundedSize: { default: "full" },
+    fallbackSrc: { default: void 0 },
+    loading: { default: "intersecting" }
+  },
+  emits: ["click", "intersecting", "loading", "loaded", "error"],
+  setup(__props, { emit: __emit }) {
+    const props = __props, emits = __emit, MazLazyImg = defineAsyncComponent(() => import("./MazLazyImg.js")), componentType = computed(() => props.to ? "RouterLink" : props.href ? "a" : "div"), isLink = computed(() => !!props.to || !!props.href);
+    function getInitials(name, lettersCount = props.letterCount) {
+      return name.split(" ").map((word) => word[0]).join("").slice(0, lettersCount);
+    }
+    const shouldDisplayImg = computed(() => props.src || !props.src && !props.caption);
+    function handleImageError(event) {
+      if (emits("error", event.target), props.fallbackSrc && event.target instanceof HTMLImageElement) {
+        const currentSrc = new URL(event.target.src), fallbackSrc = new URL(props.fallbackSrc);
+        if (currentSrc.href === fallbackSrc.href)
+          return;
+        event.target.src = props.fallbackSrc;
+      }
+    }
+    return (_ctx, _cache) => (openBlock(), createBlock(resolveDynamicComponent(componentType.value), {
+      style: normalizeStyle([{ fontSize: _ctx.size }, _ctx.style]),
+      class: normalizeClass(["m-avatar m-reset-css", [
+        {
+          "--has-link": isLink.value
+        },
+        props.class
+      ]]),
+      href: _ctx.href,
+      to: _ctx.to,
+      target: isLink.value ? _ctx.target : void 0
+    }, {
+      default: withCtx(() => [
+        createElementVNode("div", {
+          class: normalizeClass(["m-avatar__wrapper", [
+            {
+              "--has-shadow": !_ctx.noElevation,
+              "--bordered": _ctx.bordered,
+              "--clickable": _ctx.clickable,
+              "--has-initial": !_ctx.src && _ctx.caption
+            },
+            `--rounded-${_ctx.square ? "none" : _ctx.roundedSize}`
+          ]]),
+          tabindex: _ctx.clickable ? 0 : -1
+        }, [
+          shouldDisplayImg.value ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
+            _ctx.loading === "intersecting" ? (openBlock(), createBlock(unref(MazLazyImg), mergeProps({ key: 0 }, _ctx.$attrs, {
+              class: "m-avatar__picture maz-w-full maz-max-w-full",
+              src: _ctx.src,
+              alt: _ctx.alt,
+              "image-height-full": "",
+              "hide-loader": _ctx.hideLoader,
+              "fallback-src": _ctx.fallbackSrc,
+              onClick: _cache[0] || (_cache[0] = ($event) => _ctx.clickable ? _ctx.$emit("click", $event) : null),
+              onError: _cache[1] || (_cache[1] = ($event) => _ctx.$emit("error", $event)),
+              onLoaded: _cache[2] || (_cache[2] = ($event) => _ctx.$emit("loaded", $event)),
+              onLoading: _cache[3] || (_cache[3] = ($event) => _ctx.$emit("loading", $event)),
+              onIntersecting: _cache[4] || (_cache[4] = ($event) => _ctx.$emit("intersecting", $event))
+            }), null, 16, ["src", "alt", "hide-loader", "fallback-src"])) : (openBlock(), createElementBlock("img", {
+              key: 1,
+              class: "m-avatar__picture maz-w-full maz-max-w-full",
+              src: _ctx.src ?? _ctx.fallbackSrc,
+              alt: _ctx.alt,
+              loading: _ctx.loading,
+              onError: handleImageError
+            }, null, 40, _hoisted_2))
+          ], 64)) : createCommentVNode("", !0),
+          _ctx.caption && !_ctx.src ? renderSlot(_ctx.$slots, "round-text", { key: 1 }, () => [
+            createElementVNode("span", _hoisted_3, toDisplayString(getInitials(_ctx.caption)), 1)
+          ], !0) : createCommentVNode("", !0),
+          _ctx.clickable ? (openBlock(), createElementBlock("button", {
+            key: 2,
+            type: "button",
+            tabindex: "-1",
+            class: "m-avatar__button",
+            style: normalizeStyle({
+              backgroundColor: _ctx.src ? `hsl(var(--maz-${_ctx.buttonColor}) / 60%)` : `hsl(var(--maz-${_ctx.buttonColor}))`
+            }),
+            onClick: _cache[5] || (_cache[5] = ($event) => _ctx.$emit("click", $event))
+          }, [
+            _ctx.hideClickableIcon ? createCommentVNode("", !0) : renderSlot(_ctx.$slots, "icon", { key: 0 }, () => [
+              createVNode(unref(MazPencil), { class: "m-avatar__button__icon" })
+            ], !0)
+          ], 4)) : createCommentVNode("", !0)
+        ], 10, _hoisted_1),
+        renderSlot(_ctx.$slots, "caption", {}, () => [
+          _ctx.showCaption && _ctx.caption ? (openBlock(), createElementBlock("p", _hoisted_4, toDisplayString(_ctx.caption), 1)) : createCommentVNode("", !0)
+        ], !0)
+      ]),
+      _: 3
+    }, 8, ["style", "class", "href", "to", "target"]));
+  }
+}), MazAvatar = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-1de486b2"]]);
+export {
+  MazAvatar as default
+};

package/dist/components/MazBackdrop.js

@@ -0,0 +1,124 @@
+import { defineComponent, ref, onMounted, watch, nextTick, createBlock, openBlock, Teleport, createVNode, Transition, withCtx, createElementBlock, createCommentVNode, mergeProps, createElementVNode, withModifiers, normalizeClass, renderSlot } from "vue";
+import { _ as _export_sfc } from "../chunks/_plugin-vue_export-helper.B--vMWp3.js";
+import '../assets/MazBackdrop.DNpnLh63.css';const _hoisted_1 = {
+  role: "dialog",
+  class: "m-backdrop-container",
+  "aria-modal": "true"
+}, _hoisted_2 = { class: "m-backdrop-wrapper" }, MODAL_OPENED_CLASS = "--backdrop-present", _sfc_main = /* @__PURE__ */ defineComponent({
+  inheritAttrs: !1,
+  __name: "MazBackdrop",
+  props: {
+    modelValue: { type: Boolean, default: !1 },
+    teleportSelector: { default: "body" },
+    beforeClose: { type: Function },
+    persistent: { type: Boolean, default: !1 },
+    closeOnEscape: { type: Boolean, default: !0 },
+    transitionName: { default: "backdrop-anim" },
+    backdropClass: {},
+    backdropContentClass: {},
+    contentPadding: { type: Boolean, default: !1 },
+    justify: { default: "none" },
+    align: { default: "none" },
+    variant: {}
+  },
+  emits: ["open", "close", "update:model-value", "before-close"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const emits = __emit;
+    function getScrollbarWidth() {
+      return window.innerWidth - document.documentElement.clientWidth;
+    }
+    function addClassToDocument() {
+      const scrollbarWidth = getScrollbarWidth();
+      scrollbarWidth > 0 && (document.documentElement.style.setProperty("--scrollbar-width", `${scrollbarWidth}px`), document.documentElement.classList.add("--has-scrollbar")), document.documentElement.classList.add(MODAL_OPENED_CLASS);
+    }
+    function removeClassFromDocument() {
+      document.querySelector(".m-backdrop.--present") || (document.documentElement.classList.remove(MODAL_OPENED_CLASS), document.documentElement.classList.remove("--has-scrollbar"), document.documentElement.style.removeProperty("--scrollbar-width"));
+    }
+    const present = ref(__props.modelValue);
+    function close() {
+      toggleModal(!1);
+    }
+    async function toggleModal(value) {
+      value || (emits("before-close"), await __props.beforeClose?.()), present.value = value;
+    }
+    function onBackdropAnimationEnter() {
+      emits("open");
+    }
+    function onBackdropAnimationLeave() {
+      emits("update:model-value", !1), emits("close"), removeClassAndEventToDocument();
+    }
+    function onBackdropClicked() {
+      __props.persistent || close();
+    }
+    function onKeyPress(event) {
+      __props.closeOnEscape && event.key === "Escape" && !__props.persistent && close();
+    }
+    function addClassAndEventToDocument() {
+      addClassToDocument(), document.addEventListener("keyup", onKeyPress, !1);
+    }
+    function removeClassAndEventToDocument() {
+      document.removeEventListener("keyup", onKeyPress), removeClassFromDocument();
+    }
+    onMounted(() => {
+      __props.modelValue ? addClassAndEventToDocument() : removeClassAndEventToDocument();
+    });
+    let initialFocusableElement = null;
+    function findFirstFocusableElement(selector) {
+      const modal = document.querySelector(selector), visibleFocusableElements = (modal && Array.from(modal.querySelectorAll('a[href], button, textarea, input[type="text"], input[type="radio"], input[type="checkbox"], select')))?.filter((el) => {
+        const style = window.getComputedStyle(el);
+        return style.display !== "none" && style.visibility !== "hidden" && !el.disabled;
+      });
+      return visibleFocusableElements && visibleFocusableElements.length > 0 ? visibleFocusableElements[0] : null;
+    }
+    return watch(
+      () => __props.modelValue,
+      async (value) => {
+        present.value = value, value ? (addClassAndEventToDocument(), initialFocusableElement = document.activeElement, await nextTick(), findFirstFocusableElement(".m-backdrop-content")?.focus()) : (removeClassAndEventToDocument(), await nextTick(), initialFocusableElement?.focus());
+      }
+    ), __expose({
+      onBackdropAnimationEnter,
+      onBackdropAnimationLeave,
+      onBackdropClicked,
+      close,
+      present,
+      toggleModal,
+      onKeyPress
+    }), (_ctx, _cache) => (openBlock(), createBlock(Teleport, { to: _ctx.teleportSelector }, [
+      createVNode(Transition, {
+        appear: "",
+        name: _ctx.transitionName,
+        onAfterEnter: onBackdropAnimationEnter,
+        onAfterLeave: onBackdropAnimationLeave
+      }, {
+        default: withCtx(() => [
+          present.value ? (openBlock(), createElementBlock("div", mergeProps({
+            key: 0,
+            class: "m-backdrop --present m-reset-css"
+          }, _ctx.$attrs, {
+            class: [_ctx.backdropClass, _ctx.variant && `--variant-${_ctx.variant}`, { "--persistent": _ctx.persistent }]
+          }), [
+            createElementVNode("div", _hoisted_1, [
+              createElementVNode("div", _hoisted_2, [
+                createElementVNode("div", {
+                  class: normalizeClass(["m-backdrop-content", [_ctx.backdropContentClass, `--justify-${_ctx.justify}`, `--align-${_ctx.align}`, { "--padding": _ctx.contentPadding }]]),
+                  role: "button",
+                  tabindex: "-1",
+                  onClick: withModifiers(onBackdropClicked, ["self"])
+                }, [
+                  renderSlot(_ctx.$slots, "default", {
+                    close,
+                    onBackdropClicked
+                  }, void 0, !0)
+                ], 2)
+              ])
+            ])
+          ], 16)) : createCommentVNode("", !0)
+        ]),
+        _: 3
+      }, 8, ["name"])
+    ], 8, ["to"]));
+  }
+}), MazBackdrop = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-92b68934"]]);
+export {
+  MazBackdrop as default
+};

package/dist/components/MazBadge.js

@@ -0,0 +1,28 @@
+import { defineComponent, createElementBlock, openBlock, normalizeStyle, normalizeClass, renderSlot } from "vue";
+import { _ as _export_sfc } from "../chunks/_plugin-vue_export-helper.B--vMWp3.js";
+import '../assets/MazBadge.DN8tdE8_.css';const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "MazBadge",
+  props: {
+    color: { default: "primary" },
+    size: { default: "0.8em" },
+    nowrap: { type: Boolean, default: !1 },
+    outlined: { type: Boolean, default: !1 },
+    pastel: { type: Boolean, default: !1 },
+    roundedSize: { default: "md" }
+  },
+  setup(__props) {
+    return (_ctx, _cache) => (openBlock(), createElementBlock("span", {
+      class: normalizeClass(["m-badge m-reset-css", [
+        `--${_ctx.color}`,
+        { "--outlined": _ctx.outlined, "--pastel": _ctx.pastel, "--nowrap": _ctx.nowrap },
+        `--rounded-${_ctx.roundedSize}`
+      ]]),
+      style: normalizeStyle({ fontSize: _ctx.size })
+    }, [
+      renderSlot(_ctx.$slots, "default", {}, void 0, !0)
+    ], 6));
+  }
+}), MazBadge = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-75298911"]]);
+export {
+  MazBadge as default
+};

package/dist/components/MazBottomSheet.js

@@ -0,0 +1,54 @@
+import { defineComponent, defineAsyncComponent, createBlock, openBlock, withCtx, createElementVNode, normalizeClass, renderSlot, createCommentVNode, unref, createVNode } from "vue";
+import { MazXMark } from "@maz-ui/icons";
+import MazBackdrop from "./MazBackdrop.js";
+import { _ as _export_sfc } from "../chunks/_plugin-vue_export-helper.B--vMWp3.js";
+import '../assets/MazBottomSheet.DKDf6Eet.css';const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "MazBottomSheet",
+  props: {
+    modelValue: { type: Boolean },
+    hideCloseButton: { type: Boolean, default: !1 },
+    padding: { type: Boolean, default: !0 }
+  },
+  emits: ["update:model-value", "open", "close"],
+  setup(__props, { emit: __emit }) {
+    const emits = __emit, MazBtn = defineAsyncComponent(() => import("./MazBtn.js"));
+    return (_ctx, _cache) => (openBlock(), createBlock(MazBackdrop, {
+      "model-value": _ctx.modelValue,
+      "transition-name": "bottom-sheet-anim",
+      "backdrop-class": "--bottom-sheet",
+      "content-padding": !1,
+      align: "end",
+      justify: "none",
+      variant: "bottom-sheet",
+      onClose: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("close", $event)),
+      onOpen: _cache[1] || (_cache[1] = ($event) => _ctx.$emit("open", $event)),
+      "onUpdate:modelValue": _cache[2] || (_cache[2] = ($event) => emits("update:model-value", $event))
+    }, {
+      default: withCtx(({ close }) => [
+        createElementVNode("div", {
+          class: normalizeClass(["m-bottom-sheet__container", {
+            "--padding": _ctx.padding
+          }])
+        }, [
+          renderSlot(_ctx.$slots, "default", { close }, void 0, !0),
+          _ctx.hideCloseButton ? createCommentVNode("", !0) : (openBlock(), createBlock(unref(MazBtn), {
+            key: 0,
+            size: "sm",
+            class: "m-bottom-sheet__close",
+            color: "transparent",
+            onClick: close
+          }, {
+            default: withCtx(() => [
+              createVNode(unref(MazXMark), { class: "maz-text-lg" })
+            ]),
+            _: 2
+          }, 1032, ["onClick"]))
+        ], 2)
+      ]),
+      _: 3
+    }, 8, ["model-value"]));
+  }
+}), MazBottomSheet = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-e9ab4fa6"]]);
+export {
+  MazBottomSheet as default
+};

package/dist/components/MazBtn.js

@@ -0,0 +1,92 @@
+import { defineComponent, defineAsyncComponent, useAttrs, computed, createBlock, openBlock, resolveDynamicComponent, normalizeStyle, normalizeClass, withCtx, renderSlot, createElementBlock, createCommentVNode, unref, createTextVNode, toDisplayString, createVNode } from "vue";
+import { _ as _export_sfc } from "../chunks/_plugin-vue_export-helper.B--vMWp3.js";
+import '../assets/MazBtn.BnRxVlqS.css';const _hoisted_1 = {
+  key: 0,
+  class: "m-btn-loader-container"
+}, _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "MazBtn",
+  props: {
+    text: {},
+    size: { default: "md" },
+    color: { default: "primary" },
+    type: { default: "button" },
+    roundedSize: { default: "lg" },
+    outlined: { type: Boolean },
+    pastel: { type: Boolean },
+    block: { type: Boolean },
+    loading: { type: Boolean },
+    disabled: { type: Boolean },
+    fab: { type: Boolean },
+    icon: { type: [String, Function, Object] },
+    leftIcon: { type: [String, Function, Object] },
+    rightIcon: { type: [String, Function, Object] },
+    padding: { type: Boolean, default: !0 },
+    justify: { default: "center" }
+  },
+  setup(__props) {
+    const MazIcon = defineAsyncComponent(() => import("./MazIcon.js")), MazSpinner = defineAsyncComponent(() => import("./MazSpinner.js")), { href, to } = useAttrs(), component = computed(() => href ? "a" : to ? "router-link" : "button"), btnColorClass = computed(() => __props.pastel ? `--${__props.color}-pastel` : __props.outlined ? `--${__props.color}-outlined` : `--${__props.color}`), isDisabled = computed(
+      () => (__props.loading || __props.disabled) && component.value === "button"
+    ), cursorClass = computed(() => isDisabled.value ? "--cursor-default" : "--cursor-pointer"), btnType = computed(() => component.value === "button" ? __props.type : void 0), iconClassSize = computed(() => __props.size === "xl" ? "maz-text-3xl" : __props.size === "lg" ? "maz-text-2xl" : __props.size === "md" ? "maz-text-xl" : __props.size === "sm" ? "maz-text-lg" : __props.size === "xs" ? "maz-text-base" : __props.size === "mini" ? "maz-text-sm" : "maz-text-xl");
+    return (_ctx, _cache) => (openBlock(), createBlock(resolveDynamicComponent(component.value), {
+      disabled: isDisabled.value,
+      class: normalizeClass(["m-btn m-reset-css", [
+        `--${_ctx.size}`,
+        !_ctx.fab && _ctx.roundedSize && `--rounded-${_ctx.roundedSize}`,
+        btnColorClass.value,
+        cursorClass.value,
+        {
+          "--block": _ctx.block,
+          "--fab": _ctx.fab,
+          "--loading": _ctx.loading,
+          "--disabled": isDisabled.value,
+          "--no-padding": !_ctx.padding
+        }
+      ]]),
+      style: normalizeStyle([`--justify: ${_ctx.justify}`, `--color: var(--maz-${_ctx.color})`]),
+      type: btnType.value
+    }, {
+      default: withCtx(() => [
+        renderSlot(_ctx.$slots, "left-icon", {}, () => [
+          typeof _ctx.leftIcon == "string" ? (openBlock(), createBlock(unref(MazIcon), {
+            key: 0,
+            name: _ctx.leftIcon,
+            class: normalizeClass([iconClassSize.value])
+          }, null, 8, ["name", "class"])) : _ctx.leftIcon ? (openBlock(), createBlock(resolveDynamicComponent(_ctx.leftIcon), {
+            key: 1,
+            class: normalizeClass([iconClassSize.value])
+          }, null, 8, ["class"])) : createCommentVNode("", !0)
+        ], !0),
+        renderSlot(_ctx.$slots, "icon", {}, () => [
+          typeof _ctx.icon == "string" ? (openBlock(), createBlock(unref(MazIcon), {
+            key: 0,
+            name: _ctx.icon,
+            class: normalizeClass([iconClassSize.value])
+          }, null, 8, ["name", "class"])) : _ctx.icon ? (openBlock(), createBlock(resolveDynamicComponent(_ctx.icon), {
+            key: 1,
+            class: normalizeClass([iconClassSize.value])
+          }, null, 8, ["class"])) : createCommentVNode("", !0)
+        ], !0),
+        renderSlot(_ctx.$slots, "default", {}, () => [
+          createTextVNode(toDisplayString(_ctx.text), 1)
+        ], !0),
+        renderSlot(_ctx.$slots, "right-icon", {}, () => [
+          typeof _ctx.rightIcon == "string" ? (openBlock(), createBlock(unref(MazIcon), {
+            key: 0,
+            name: _ctx.rightIcon,
+            class: normalizeClass([iconClassSize.value])
+          }, null, 8, ["name", "class"])) : _ctx.rightIcon ? (openBlock(), createBlock(resolveDynamicComponent(_ctx.rightIcon), {
+            key: 1,
+            class: normalizeClass([iconClassSize.value])
+          }, null, 8, ["class"])) : createCommentVNode("", !0)
+        ], !0),
+        _ctx.loading ? (openBlock(), createElementBlock("div", _hoisted_1, [
+          createVNode(unref(MazSpinner), { size: "2em" })
+        ])) : createCommentVNode("", !0)
+      ]),
+      _: 3
+    }, 8, ["disabled", "class", "style", "type"]));
+  }
+}), MazBtn = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-b725eb4b"]]);
+export {
+  MazBtn as default
+};