maz-ui 3.28.9 → 3.29.1

package/components/MazAvatar.d.ts

@@ -71,6 +71,11 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
         type: NumberConstructor;
         default: undefined;
     };
+    roundedSize: {
+        type: PropType<"sm" | "md" | "lg" | "xl" | "none" | "full">;
+        default: string;
+        validator: (value: string) => boolean;
+    };
 }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     click: (...args: any[]) => void;
 }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
@@ -143,6 +148,11 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
         type: NumberConstructor;
         default: undefined;
     };
+    roundedSize: {
+        type: PropType<"sm" | "md" | "lg" | "xl" | "none" | "full">;
+        default: string;
+        validator: (value: string) => boolean;
+    };
 }>> & {
     onClick?: ((...args: any[]) => any) | undefined;
 }, {
@@ -163,6 +173,7 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
     buttonColor: Color;
     noClickableIcon: boolean;
     letterCount: number;
+    roundedSize: "sm" | "md" | "lg" | "xl" | "none" | "full";
 }, {}>, {
     "round-text"?(_: {}): any;
     icon?(_: {}): any;

package/components/MazAvatar.mjs

@@ -1,4 +1,4 @@
-import { M as f } from "./chunks/MazAvatar-HJMP2asX.mjs";
+import { M as f } from "./chunks/MazAvatar-0JzIvOc4.mjs";
 export {
   f as default
 };

package/components/MazBadge.d.ts

@@ -24,7 +24,7 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
         default: boolean;
     };
     roundedSize: {
-        type: StringConstructor;
+        type: PropType<"sm" | "md" | "lg" | "xl" | "none" | "full">;
         default: string;
         validator: (value: string) => boolean;
     };
@@ -51,7 +51,7 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
         default: boolean;
     };
     roundedSize: {
-        type: StringConstructor;
+        type: PropType<"sm" | "md" | "lg" | "xl" | "none" | "full">;
         default: string;
         validator: (value: string) => boolean;
     };
@@ -60,8 +60,8 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
     color: BadgeColor;
     outline: boolean;
     pastel: boolean;
+    roundedSize: "sm" | "md" | "lg" | "xl" | "none" | "full";
     nowrap: boolean;
-    roundedSize: string;
 }, {}>, {
     default?(_: {}): any;
 }>;

package/components/MazBadge.mjs

@@ -51,7 +51,7 @@ const c = /* @__PURE__ */ l({
   for (const [n, o] of t)
     a[n] = o;
   return a;
-}, y = /* @__PURE__ */ f(c, [["__scopeId", "data-v-3f8b9fee"]]);
+}, y = /* @__PURE__ */ f(c, [["__scopeId", "data-v-8368c7f0"]]);
 export {
   y as default
 };

package/components/MazInputCode.d.ts

@@ -0,0 +1,153 @@
+import { type PropType } from 'vue';
+import type { Color } from './types';
+export type { Color } from './types';
+declare const _default: import("vue").DefineComponent<{
+    style: {
+        type: PropType<import("vue").StyleValue>;
+        default: undefined;
+    };
+    class: {
+        type: PropType<any>;
+        default: undefined;
+    };
+    /** Is v-model */
+    modelValue: {
+        type: PropType<string | number>;
+        default: undefined;
+    };
+    /** Choose the length of the code */
+    codeLength: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Is the returned type (number works only when accept-alpha is not enable) */
+    type: {
+        type: PropType<"number" | "text">;
+        default: string;
+    };
+    /** Turn it to true to accept alpha charac */
+    acceptAlpha: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** make inputs required */
+    required: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** make inputs required */
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** When is `true` the input has the error style (danger color) */
+    error: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** When is `true` the input has the success style (success color) */
+    success: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** When is `true` the input has the warning style (warning color) */
+    warning: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Predefined size of component */
+    size: {
+        type: PropType<"sm" | "md" | "lg">;
+        default: string;
+    };
+    /** Color of component */
+    color: {
+        type: PropType<Color>;
+        default: string;
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:model-value": (...args: any[]) => void;
+    completed: (...args: any[]) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    style: {
+        type: PropType<import("vue").StyleValue>;
+        default: undefined;
+    };
+    class: {
+        type: PropType<any>;
+        default: undefined;
+    };
+    /** Is v-model */
+    modelValue: {
+        type: PropType<string | number>;
+        default: undefined;
+    };
+    /** Choose the length of the code */
+    codeLength: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Is the returned type (number works only when accept-alpha is not enable) */
+    type: {
+        type: PropType<"number" | "text">;
+        default: string;
+    };
+    /** Turn it to true to accept alpha charac */
+    acceptAlpha: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** make inputs required */
+    required: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** make inputs required */
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** When is `true` the input has the error style (danger color) */
+    error: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** When is `true` the input has the success style (success color) */
+    success: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** When is `true` the input has the warning style (warning color) */
+    warning: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Predefined size of component */
+    size: {
+        type: PropType<"sm" | "md" | "lg">;
+        default: string;
+    };
+    /** Color of component */
+    color: {
+        type: PropType<Color>;
+        default: string;
+    };
+}>> & {
+    "onUpdate:model-value"?: ((...args: any[]) => any) | undefined;
+    onCompleted?: ((...args: any[]) => any) | undefined;
+}, {
+    success: boolean;
+    warning: boolean;
+    size: "sm" | "md" | "lg";
+    color: Color;
+    type: "number" | "text";
+    style: import("vue").StyleValue;
+    class: any;
+    disabled: boolean;
+    required: boolean;
+    error: boolean;
+    modelValue: string | number;
+    codeLength: number;
+    acceptAlpha: boolean;
+}, {}>;
+export default _default;

package/components/MazInputCode.mjs

@@ -0,0 +1,189 @@
+import "./assets/MazInputCode.css";
+import { defineComponent as N, useCssVars as C, ref as b, watch as k, computed as m, openBlock as g, createElementBlock as v, normalizeClass as V, normalizeStyle as M, Fragment as P, renderList as j, createCommentVNode as q, createElementVNode as O, mergeProps as $ } from "vue";
+const D = ["disabled"], E = ["inputmode", "pattern", "required", "value", "onInput", "onKeydown"], F = /* @__PURE__ */ N({
+  inheritAttrs: !1,
+  __name: "MazInputCode",
+  props: {
+    style: {
+      type: [String, Array, Object],
+      default: void 0
+    },
+    class: {
+      type: [String, Array, Object],
+      default: void 0
+    },
+    /** Is v-model */
+    modelValue: {
+      type: [String, Number],
+      default: void 0
+    },
+    /** Choose the length of the code */
+    codeLength: { type: Number, default: 4 },
+    /** Is the returned type (number works only when accept-alpha is not enable) */
+    type: {
+      type: String,
+      default: "text"
+    },
+    /** Turn it to true to accept alpha charac */
+    acceptAlpha: { type: Boolean, default: !1 },
+    /** make inputs required */
+    required: { type: Boolean, default: !1 },
+    /** make inputs required */
+    disabled: { type: Boolean, default: !1 },
+    /** When is `true` the input has the error style (danger color) */
+    error: { type: Boolean, default: !1 },
+    /** When is `true` the input has the success style (success color) */
+    success: { type: Boolean, default: !1 },
+    /** When is `true` the input has the warning style (warning color) */
+    warning: { type: Boolean, default: !1 },
+    /** Predefined size of component */
+    size: {
+      type: String,
+      default: "md"
+    },
+    /** Color of component */
+    color: {
+      type: String,
+      default: "primary"
+    }
+  },
+  emits: [
+    /**
+     * update the model
+     */
+    "update:model-value",
+    /**
+     * Emitted when all inputs are set.
+     */
+    "completed"
+  ],
+  setup(l, { emit: d }) {
+    C((t) => ({
+      "6bdbc0e0": L.value
+    }));
+    const a = l, c = d, i = b([]), r = b(/* @__PURE__ */ new Map());
+    k(
+      () => a.modelValue,
+      (t, e) => {
+        t !== e && (r.value = x());
+      },
+      { immediate: !0 }
+    );
+    const f = m({
+      get: () => r.value,
+      set: (t) => {
+        const e = I(t);
+        c("update:model-value", e), (e == null ? void 0 : e.toString().length) === a.codeLength && c("completed");
+      }
+    });
+    function x(t = a.modelValue) {
+      const e = /* @__PURE__ */ new Map();
+      for (const n of Array.from({ length: a.codeLength }, (o, u) => u))
+        if (t === void 0)
+          e.set(n + 1, void 0);
+        else {
+          const o = [...t.toString()];
+          e.set(n + 1, o[n]);
+        }
+      return e;
+    }
+    function z(t, e) {
+      var o;
+      const n = y((o = t.target) == null ? void 0 : o.value);
+      f.value = r.value.set(e, n), n && p(e);
+    }
+    function I(t) {
+      const e = [...t.values()].join("");
+      return a.type === "text" ? e : e && !Number.isNaN(Number(e)) ? Number(e) : void 0;
+    }
+    function y(t) {
+      var e;
+      return (e = a.acceptAlpha ? t.match(/^[\w.]$/i) : t.match(/\d+/g)) == null ? void 0 : e.toString();
+    }
+    function S(t, e) {
+      const n = r.value.get(e);
+      if (t.key === "Backspace" && !n) {
+        const o = e - 1 < 0 ? 0 : e - 1;
+        f.value = r.value.set(o, void 0), p(o - 1);
+      }
+    }
+    function w(t) {
+      var o;
+      const e = (o = t.clipboardData) == null ? void 0 : o.getData("text");
+      if (!e)
+        return;
+      const n = Array.from({ length: a.codeLength }, (u, s) => ({
+        index: s + 1,
+        value: [...e.toString()][s] ?? void 0
+      }));
+      for (const { index: u, value: s } of n) {
+        const h = s ? y(s) : void 0;
+        h && r.value.set(u, h);
+      }
+      setTimeout(() => {
+        const u = A(), s = u >= a.codeLength ? a.codeLength - 1 : u;
+        p(s, !1);
+      }, 0);
+    }
+    function A() {
+      return [...r.value.values()].filter(Boolean).length;
+    }
+    function p(t, e = !0) {
+      setTimeout(() => {
+        const n = i.value[t];
+        t + 1 > a.codeLength || !n || (n.focus(), e && n.select());
+      }, 0);
+    }
+    const B = m(() => a.error ? "!maz-border-danger" : a.success ? "!maz-border-success" : a.warning ? "!maz-border-warning" : ""), L = m(() => `var(--maz-color-${a.color})`);
+    return (t, e) => (g(), v("fieldset", {
+      class: V(["m-input-code", [l.size ? `--${l.size}` : void 0]]),
+      disabled: l.disabled,
+      style: M(l.style)
+    }, [
+      (g(!0), v(
+        P,
+        null,
+        j(l.codeLength, (n) => (g(), v(
+          "div",
+          {
+            key: n,
+            class: V(["input-wrapper", B.value])
+          },
+          [
+            q(" eslint-disable-next-line vuejs-accessibility/form-control-has-label "),
+            O("input", $({
+              ref_for: !0,
+              ref: (o) => {
+                i.value[n - 1] = o;
+              },
+              type: "text",
+              minlength: "1",
+              maxlength: "1",
+              inputmode: l.acceptAlpha ? "text" : "numeric",
+              pattern: l.acceptAlpha ? "[a-zA-Z0-9]{1}" : "[0-9]{1}",
+              autocomplete: "do-not-autofill",
+              required: l.required
+            }, t.$attrs, {
+              value: f.value.get(n),
+              onInput: (o) => z(o, n),
+              onKeydown: (o) => S(o, n),
+              onPaste: w
+            }), null, 16, E)
+          ],
+          2
+          /* CLASS */
+        ))),
+        128
+        /* KEYED_FRAGMENT */
+      ))
+    ], 14, D));
+  }
+}), K = (l, d) => {
+  const a = l.__vccOpts || l;
+  for (const [c, i] of d)
+    a[c] = i;
+  return a;
+}, W = /* @__PURE__ */ K(F, [["__scopeId", "data-v-4e98f6f7"]]);
+export {
+  W as default
+};

package/components/MazInputTags.mjs

@@ -1,4 +1,4 @@
-import { M as f } from "./chunks/MazInputTags-kDTfYnsu.mjs";
+import { M as f } from "./chunks/MazInputTags-NVpcRBJU.mjs";
 export {
   f as default
 };

package/components/MazPullToRefresh.d.ts

@@ -0,0 +1,88 @@
+import type { Color } from './types';
+export type { Color } from './types';
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    distance?: number | undefined;
+    offset?: number | undefined;
+    action?: (() => unknown) | undefined;
+    containerSelector?: string | undefined;
+    headerClass?: string | undefined;
+    spinnerColor?: Color | undefined;
+    disabled?: boolean | undefined;
+    standaloneMode?: boolean | undefined;
+}>, {
+    distance: number;
+    offset: number;
+    action: undefined;
+    containerSelector: undefined;
+    headerClass: undefined;
+    spinnerColor: string;
+    disabled: boolean;
+    standaloneMode: boolean;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    error: (...args: any[]) => void;
+    loaded: (...args: any[]) => void;
+    start: (...args: any[]) => void;
+    finish: (...args: any[]) => void;
+    response: (...args: any[]) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    distance?: number | undefined;
+    offset?: number | undefined;
+    action?: (() => unknown) | undefined;
+    containerSelector?: string | undefined;
+    headerClass?: string | undefined;
+    spinnerColor?: Color | undefined;
+    disabled?: boolean | undefined;
+    standaloneMode?: boolean | undefined;
+}>, {
+    distance: number;
+    offset: number;
+    action: undefined;
+    containerSelector: undefined;
+    headerClass: undefined;
+    spinnerColor: string;
+    disabled: boolean;
+    standaloneMode: boolean;
+}>>> & {
+    onError?: ((...args: any[]) => any) | undefined;
+    onLoaded?: ((...args: any[]) => any) | undefined;
+    onStart?: ((...args: any[]) => any) | undefined;
+    onFinish?: ((...args: any[]) => any) | undefined;
+    onResponse?: ((...args: any[]) => any) | undefined;
+}, {
+    disabled: boolean;
+    action: () => unknown;
+    offset: number;
+    distance: number;
+    containerSelector: string;
+    headerClass: string;
+    spinnerColor: Color;
+    standaloneMode: boolean;
+}, {}>, {
+    "pull-before"?(_: {}): any;
+    "pull-ready"?(_: {}): any;
+    "pull-loading"?(_: {}): any;
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/components/MazPullToRefresh.mjs

@@ -0,0 +1,185 @@
+import "./assets/MazPullToRefresh.css";
+import { defineComponent as P, computed as p, ref as _, watch as R, onUnmounted as x, resolveComponent as V, openBlock as c, createElementBlock as v, normalizeClass as M, normalizeStyle as Y, renderSlot as f, createCommentVNode as y, createElementVNode as b, createVNode as $, pushScopeId as N, popScopeId as A } from "vue";
+function L() {
+  return typeof document < "u";
+}
+function H() {
+  if (!L())
+    return !1;
+  const o = navigator, d = window.matchMedia("(display-mode: standalone)").matches;
+  return o.standalone || d;
+}
+const k = (o) => (N("data-v-a874f56d"), o = o(), A(), o), q = {
+  key: 0,
+  class: "header-text"
+}, D = /* @__PURE__ */ k(() => /* @__PURE__ */ b(
+  "span",
+  null,
+  "Pull to refresh",
+  -1
+  /* HOISTED */
+)), F = {
+  key: 1,
+  class: "header-text"
+}, O = /* @__PURE__ */ k(() => /* @__PURE__ */ b(
+  "span",
+  null,
+  " Release to refresh ",
+  -1
+  /* HOISTED */
+)), U = {
+  key: 2,
+  class: "header-text"
+}, j = { class: "maz-flex maz-flex-col maz-flex-center" }, G = /* @__PURE__ */ P({
+  __name: "MazPullToRefresh",
+  props: {
+    distance: { default: 100 },
+    offset: { default: 0 },
+    action: { type: Function, default: void 0 },
+    containerSelector: { default: void 0 },
+    headerClass: { default: void 0 },
+    spinnerColor: { default: "theme" },
+    disabled: { type: Boolean, default: !1 },
+    standaloneMode: { type: Boolean, default: !1 }
+  },
+  emits: ["loaded", "start", "error", "finish", "response"],
+  setup(o, { emit: d }) {
+    const a = o, r = d, l = p(
+      () => a.disabled || a.action === void 0 || a.standaloneMode && L() && !H()
+    ), m = _({
+      top: 0,
+      bottom: 0
+    }), t = _({
+      from: -1,
+      to: -1,
+      distance: 0,
+      available: !1,
+      state: "end"
+    }), i = _(!1), s = p(() => {
+      if (typeof document > "u" || l.value)
+        return;
+      const e = a.containerSelector ? document.querySelector(a.containerSelector) : document.body;
+      if (!e)
+        throw new Error("MazPullToRefresh - container not found");
+      return e;
+    }), h = p(() => t.value.state !== "move" && t.value.state !== "end" || l.value ? 0 : t.value.distance > a.distance ? a.distance : t.value.distance);
+    function T(e) {
+      const { top: n, height: u } = e.getBoundingClientRect();
+      m.value = {
+        top: n,
+        bottom: window.innerHeight - (u + n + a.offset)
+      };
+    }
+    function g(e) {
+      i.value = e;
+    }
+    function w(e) {
+      if (i.value || m.value.top < 0 && m.value.bottom < 0 || l.value)
+        return;
+      const n = e.touches.item(0);
+      n && (t.value.state = "start", t.value.from = n.pageY);
+    }
+    function S(e) {
+      if (i.value || t.value.from < 0 || window.scrollY > 0 || l.value)
+        return;
+      const n = e.touches.item(0);
+      if (!n)
+        return;
+      t.value.to = n.pageY;
+      const u = t.value.to - t.value.from;
+      t.value.distance = u > 0 ? u : 0, t.value.available = t.value.distance >= a.distance, t.value.state = "move";
+    }
+    function E() {
+      i.value || l.value || (h.value === a.distance && t.value.state === "move" && window.scrollY <= 0 ? B() : z());
+    }
+    function z() {
+      t.value = {
+        from: -1,
+        to: -1,
+        distance: 0,
+        available: !1,
+        state: "end"
+      };
+    }
+    async function B() {
+      var e;
+      try {
+        g(!0), r("start");
+        const n = await ((e = a.action) == null ? void 0 : e.call(a));
+        r("loaded"), r("response", n);
+      } catch (n) {
+        throw r("error", n), n;
+      } finally {
+        z(), g(!1), r("finish");
+      }
+    }
+    R(
+      () => l.value,
+      (e) => {
+        e === !0 ? C() : I();
+      },
+      { immediate: !0 }
+    );
+    function I() {
+      !s.value || l.value || document === void 0 || (s.value.addEventListener("touchstart", w), s.value.addEventListener("touchmove", S), s.value.addEventListener("touchend", E), T(s.value));
+    }
+    function C() {
+      !s.value || document === void 0 || (s.value.removeEventListener("touchstart", w), s.value.removeEventListener("touchmove", S), s.value.removeEventListener("touchend", E));
+    }
+    return x(() => {
+      C();
+    }), (e, n) => {
+      const u = V("MazSpinner");
+      return c(), v(
+        "div",
+        {
+          class: M(["m-pull-to-refresh", { "--available": t.value.available || h.value > 10 }])
+        },
+        [
+          l.value ? y("v-if", !0) : (c(), v(
+            "div",
+            {
+              key: 0,
+              class: M(["loading-header", e.headerClass]),
+              style: Y({ height: h.value + "px" })
+            },
+            [
+              t.value.available ? t.value.available && !i.value ? (c(), v("div", F, [
+                f(e.$slots, "pull-ready", {}, () => [
+                  O
+                ], !0)
+              ])) : y("v-if", !0) : (c(), v("div", q, [
+                f(e.$slots, "pull-before", {}, () => [
+                  D
+                ], !0)
+              ])),
+              i.value ? (c(), v("div", U, [
+                f(e.$slots, "pull-loading", {}, () => [
+                  b("div", j, [
+                    $(u, {
+                      color: e.spinnerColor,
+                      size: "2.5em"
+                    }, null, 8, ["color"])
+                  ])
+                ], !0)
+              ])) : y("v-if", !0)
+            ],
+            6
+            /* CLASS, STYLE */
+          )),
+          f(e.$slots, "default", {}, void 0, !0)
+        ],
+        2
+        /* CLASS */
+      );
+    };
+  }
+}), J = (o, d) => {
+  const a = o.__vccOpts || o;
+  for (const [r, l] of d)
+    a[r] = l;
+  return a;
+}, W = /* @__PURE__ */ J(G, [["__scopeId", "data-v-a874f56d"]]);
+export {
+  W as default
+};