maz-ui 3.37.2 → 3.37.4

package/components/MazRadio.mjs

@@ -1,59 +1,45 @@
 import './assets/MazRadio.css';
-import { getCurrentInstance as S, computed as d, defineComponent as g, useCssVars as h, openBlock as k, createElementBlock as z, unref as f, normalizeClass as x, normalizeStyle as I, createElementVNode as i, mergeProps as C, renderSlot as V, createTextVNode as w, toDisplayString as B, pushScopeId as q, popScopeId as M } from "vue";
-const N = ({
-  componentName: e,
-  providedId: r
+import { getCurrentInstance as g, computed as r, defineComponent as S, useCssVars as y, openBlock as k, createElementBlock as z, unref as p, normalizeClass as I, normalizeStyle as C, createElementVNode as c, mergeProps as B, createCommentVNode as V, renderSlot as N, createTextVNode as _, toDisplayString as w, pushScopeId as M, popScopeId as x } from "vue";
+const D = ({
+  componentName: o,
+  providedId: t
 }) => {
-  const t = S();
-  return d(() => r ?? `${e}-${t == null ? void 0 : t.uid}`);
-}, O = (e) => (q("data-v-f5f34e8f"), e = e(), M(), e), j = ["for", "aria-checked"], A = ["id", "value", "disabled", "name", "checked"], D = /* @__PURE__ */ O(() => /* @__PURE__ */ i(
+  const a = g();
+  return r(() => t ?? `${o}-${a == null ? void 0 : a.uid}`);
+}, E = (o) => (M("data-v-0b81d1b5"), o = o(), x(), o), R = ["for", "aria-checked"], T = ["id", "value", "disabled", "name", "checked"], $ = /* @__PURE__ */ E(() => /* @__PURE__ */ c(
   "span",
   null,
   [
-    /* @__PURE__ */ i("span", { class: "round" })
+    /* @__PURE__ */ c("span", { class: "round" })
   ],
   -1
   /* HOISTED */
-)), E = /* @__PURE__ */ g({
+)), q = /* @__PURE__ */ S({
   __name: "MazRadio",
   props: {
-    style: {
-      type: [String, Array, Object],
-      default: void 0
-    },
-    class: {
-      type: [String, Array, Object],
-      default: void 0
-    },
-    label: { type: String, default: void 0 },
-    modelValue: { type: String, default: void 0 },
-    value: { type: String, required: !0 },
-    name: { type: String, required: !0 },
-    id: { type: String, default: void 0 },
-    color: {
-      type: String,
-      default: "primary"
-    },
-    size: { type: String, default: "md" },
+    style: { default: void 0 },
+    class: { default: void 0 },
+    id: { default: void 0 },
+    modelValue: { type: [String, Number, Boolean], default: void 0 },
+    value: { type: [String, Number, Boolean] },
+    name: {},
+    label: { default: void 0 },
+    color: { default: "primary" },
+    size: { default: "md" },
     disabled: { type: Boolean, default: !1 }
   },
-  emits: [
-    /* emitted when value change */
-    "update:model-value",
-    /* emited when value change */
-    "change"
-  ],
-  setup(e, { emit: r }) {
-    h((a) => ({
-      "2bb5b2cb": p.value,
-      ad373404: v.value,
-      "0a907a41": y.value
+  emits: ["update:model-value", "change"],
+  setup(o, { emit: t }) {
+    y((e) => ({
+      "8d62fd0a": f.value,
+      "1b5dc564": v.value,
+      "22c54cde": b.value
     }));
-    const t = e, n = r, s = N({
+    const a = o, n = t, s = D({
       componentName: "MazCheckbox",
-      providedId: t.id
-    }), c = d(() => t.modelValue === t.value), p = d(() => {
-      switch (t.size) {
+      providedId: a.id
+    }), i = r(() => a.modelValue === a.value), f = r(() => {
+      switch (a.size) {
         case "xl":
           return "2.25rem";
         case "lg":
@@ -67,54 +53,62 @@ const N = ({
         case "mini":
           return "1.2rem";
       }
-    }), v = d(() => `var(--maz-color-${t.color})`), y = d(
-      () => ["black", "transparent"].includes(t.color) ? "var(--maz-color-muted)" : `var(--maz-color-${t.color}-alpha)`
+    }), v = r(() => `var(--maz-color-${a.color})`), b = r(
+      () => ["black", "transparent"].includes(a.color) ? "var(--maz-color-muted)" : `var(--maz-color-${a.color}-alpha)`
     );
-    function b(a, o) {
-      ["Space"].includes(a.code) && (a.preventDefault(), u(o));
+    function h(e, l) {
+      ["Space"].includes(e.code) && (e.preventDefault(), u(l));
     }
-    function u(a) {
-      n("update:model-value", a), n("change", a);
+    function u(e) {
+      n("update:model-value", e), n("change", e);
     }
-    return (a, o) => (k(), z("label", {
-      for: f(s),
-      class: x(["m-checkbox", [{ "--disabled": e.disabled, "--selected": c.value }, t.class]]),
+    return (e, l) => (k(), z("label", {
+      for: p(s),
+      class: I(["m-checkbox", [{ "--disabled": e.disabled, "--selected": i.value }, a.class]]),
       tabindex: "0",
       role: "radio",
-      style: I(e.style),
-      "aria-checked": c.value,
-      onKeydown: o[1] || (o[1] = (l) => b(l, e.value))
+      style: C(e.style),
+      "aria-checked": i.value,
+      onKeydown: l[1] || (l[1] = (d) => h(d, e.value))
     }, [
-      i("input", C({
-        id: f(s),
+      c("input", B({
+        id: p(s),
         value: e.value
-      }, a.$attrs, {
+      }, e.$attrs, {
         tabindex: "-1",
         disabled: e.disabled,
         name: e.name,
         type: "radio",
-        checked: c.value,
-        onChange: o[0] || (o[0] = (l) => {
+        checked: i.value,
+        onChange: l[0] || (l[0] = (d) => {
           var m;
-          return u((m = l == null ? void 0 : l.target) == null ? void 0 : m.value);
+          return u((m = d == null ? void 0 : d.target) == null ? void 0 : m.value);
         })
-      }), null, 16, A),
-      D,
-      V(a.$slots, "default", {}, () => [
-        w(
-          B(e.label),
+      }), null, 16, T),
+      $,
+      V(`
+      @slot Label of the radio
+        @binding {Boolean} is-selected - If the radio is selected
+        @binding {string | number | boolean} value - The value of the radio
+    `),
+      N(e.$slots, "default", {
+        isSelected: i.value,
+        value: e.value
+      }, () => [
+        _(
+          w(e.label),
           1
           /* TEXT */
         )
       ], !0)
-    ], 46, j));
+    ], 46, R));
   }
-}), R = (e, r) => {
-  const t = e.__vccOpts || e;
-  for (const [n, s] of r)
-    t[n] = s;
-  return t;
-}, H = /* @__PURE__ */ R(E, [["__scopeId", "data-v-f5f34e8f"]]);
+}), H = (o, t) => {
+  const a = o.__vccOpts || o;
+  for (const [n, s] of t)
+    a[n] = s;
+  return a;
+}, L = /* @__PURE__ */ H(q, [["__scopeId", "data-v-0b81d1b5"]]);
 export {
-  H as default
+  L as default
 };

package/components/MazRadioButtons.d.ts

@@ -1,71 +1,76 @@
-import type { PropType } from 'vue';
+import { type StyleValue } from 'vue';
 import type { Color } from './types';
-export interface ButtonsRadioOption {
+export type ButtonsRadioOption = {
+    /** The label of the option */
     label: string;
-    value: string | number;
-}
-declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
-    modelValue: {
-        type: (StringConstructor | NumberConstructor)[];
-        default: undefined;
-    };
-    options: {
-        type: PropType<ButtonsRadioOption[]>;
-        required: true;
-    };
-    name: {
-        type: PropType<string>;
-        default: string;
-    };
-    color: {
-        type: PropType<Color>;
-        default: string;
-    };
-    noElevation: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    orientation: {
-        type: PropType<"col" | "row">;
-        default: string;
-    };
-}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    change: (...args: any[]) => void;
-    "update:model-value": (...args: any[]) => void;
-}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-    modelValue: {
-        type: (StringConstructor | NumberConstructor)[];
-        default: undefined;
-    };
-    options: {
-        type: PropType<ButtonsRadioOption[]>;
-        required: true;
-    };
-    name: {
-        type: PropType<string>;
-        default: string;
-    };
-    color: {
-        type: PropType<Color>;
-        default: string;
-    };
-    noElevation: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    orientation: {
-        type: PropType<"col" | "row">;
-        default: string;
-    };
-}>> & {
-    onChange?: ((...args: any[]) => any) | undefined;
-    "onUpdate:model-value"?: ((...args: any[]) => any) | undefined;
+    /** The value of the option */
+    value: string | number | boolean;
+    /** The classes to apply to the option */
+    classes?: any;
+    /** The style to apply to the option */
+    style?: StyleValue;
+} & Record<string, unknown>;
+export type Props = {
+    /** @model The value of the selected option */
+    modelValue?: string | number | boolean;
+    /** The options to display */
+    options: ButtonsRadioOption[];
+    /** The name of the radio group */
+    name?: string;
+    /** The color of the selected radio buttons */
+    color?: Color;
+    /** Add elevation to the radio buttons */
+    elevation?: boolean;
+    /**
+     * The orientation of the radio buttons
+     * @values 'row' | 'col'
+     */
+    orientation?: 'row' | 'col';
+    /** Disable the wrap of the radio buttons */
+    noWrap?: boolean;
+    /** Make all radio buttons the same size */
+    equalSize?: boolean;
+    /** Display a selector icon */
+    selector?: boolean;
+    /** The component will be displayed in full width */
+    block?: boolean;
+};
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<Props>, {
+    modelValue: undefined;
+    name: string;
+    color: string;
+    elevation: boolean;
+    orientation: string;
+    noWrap: boolean;
+    equalSize: boolean;
+    selector: boolean;
+    block: boolean;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:model-value": (value: string | number | boolean) => void;
+    change: (value: string | number | boolean) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<Props>, {
+    modelValue: undefined;
+    name: string;
+    color: string;
+    elevation: boolean;
+    orientation: string;
+    noWrap: boolean;
+    equalSize: boolean;
+    selector: boolean;
+    block: boolean;
+}>>> & {
+    onChange?: ((value: string | number | boolean) => any) | undefined;
+    "onUpdate:model-value"?: ((value: string | number | boolean) => any) | undefined;
 }, {
     name: string;
     orientation: "col" | "row";
     color: Color;
-    noElevation: boolean;
-    modelValue: string | number;
+    block: boolean;
+    modelValue: string | number | boolean;
+    elevation: boolean;
+    noWrap: boolean;
+    equalSize: boolean;
+    selector: boolean;
 }, {}>, {
     default?(_: {
         option: ButtonsRadioOption;
@@ -73,8 +78,25 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
     }): any;
 }>;
 export default _default;
+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;
     };
 };
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<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;
+    };
+};

package/components/MazRadioButtons.mjs

@@ -1,79 +1,131 @@
 import './assets/MazRadioButtons.css';
-import { defineComponent as y, openBlock as c, createElementBlock as u, normalizeClass as m, Fragment as g, renderList as z, normalizeStyle as S, createElementVNode as h, renderSlot as b, createTextVNode as k, toDisplayString as p } from "vue";
-const x = ["for", "aria-checked", "onKeydown"], B = ["id", "name", "value", "onChange"], w = /* @__PURE__ */ y({
+import { defineComponent as z, defineAsyncComponent as k, openBlock as r, createElementBlock as s, normalizeClass as c, Fragment as _, renderList as B, normalizeStyle as p, createElementVNode as b, createVNode as h, Transition as S, withCtx as $, withDirectives as C, unref as w, vShow as V, createCommentVNode as y, renderSlot as N, createTextVNode as q, toDisplayString as D } from "vue";
+const I = ["for", "aria-checked", "onKeydown"], M = ["id", "name", "value", "onChange"], R = {
+  key: 0,
+  class: "m-radio-buttons__items__checkbox"
+}, T = /* @__PURE__ */ z({
   __name: "MazRadioButtons",
   props: {
-    modelValue: { type: [String, Number], default: void 0 },
-    options: { type: Array, required: !0 },
-    name: {
-      type: String,
-      default: "MazButtonsRadio"
-    },
-    color: {
-      type: String,
-      default: "primary"
-    },
-    noElevation: { type: Boolean, default: !1 },
-    orientation: { type: String, default: "row" }
+    modelValue: { type: [String, Number, Boolean], default: void 0 },
+    options: {},
+    name: { default: "MazButtonsRadio" },
+    color: { default: "primary" },
+    elevation: { type: Boolean, default: !1 },
+    orientation: { default: "row" },
+    noWrap: { type: Boolean, default: !1 },
+    equalSize: { type: Boolean, default: !1 },
+    selector: { type: Boolean, default: !1 },
+    block: { type: Boolean, default: !1 }
   },
   emits: ["update:model-value", "change"],
-  setup(t, { emit: r }) {
-    const o = t, d = r;
-    function l(a) {
-      d("update:model-value", a.value);
+  setup(l, { emit: u }) {
+    const t = k(() => import("./chunks/check-CL-vqe79.mjs")), n = l, d = u;
+    function m(e) {
+      d("update:model-value", e.value);
     }
-    function n(a) {
-      return o.modelValue === a;
+    function o(e) {
+      return n.modelValue === e;
     }
-    function v(a, i) {
-      ["Space"].includes(a.code) && (a.preventDefault(), l(i));
+    function g(e, f) {
+      ["Space"].includes(e.code) && (e.preventDefault(), m(f));
     }
-    return (a, i) => (c(), u(
+    return (e, f) => (r(), s(
       "div",
       {
-        class: m(["m-radio-buttons", [t.orientation === "row" ? "maz-flex-row" : "maz-flex-col"]])
+        class: c(["m-radio-buttons", [`--${e.orientation}`, { "--no-wrap": e.noWrap, "--block": e.block }]])
       },
       [
-        (c(!0), u(
-          g,
+        (r(!0), s(
+          _,
           null,
-          z(t.options, (e, f) => (c(), u("label", {
-            key: f,
-            for: e.value.toString(),
-            class: m(["m-radio-buttons__items", {
-              "--is-selected": n(e.value),
-              "maz-elevation": !t.noElevation
-            }]),
+          B(e.options, (a, i) => (r(), s("label", {
+            key: `option-${i}-${a.value.toString()}`,
+            for: `option-${i}-${a.value.toString()}`,
+            class: c(["m-radio-buttons__items maz-group", [
+              {
+                "--is-selected": o(a.value),
+                "--elevation": e.elevation,
+                "--equal-size": e.equalSize
+              },
+              a.classes
+            ]]),
             tabindex: "0",
-            style: S(
-              n(e.value) ? {
-                color: `var(--maz-color-${t.color}-contrast)`,
-                backgroundColor: `var(--maz-color-${t.color})`
-              } : void 0
-            ),
+            style: p([
+              o(a.value) ? {
+                color: `var(--maz-color-${e.color}-contrast)`,
+                backgroundColor: `var(--maz-color-${e.color})`
+              } : {},
+              a.style
+            ]),
             role: "radio",
-            "aria-checked": n(e.value),
-            onKeydown: (s) => v(s, e)
+            "aria-checked": o(a.value),
+            onKeydown: (v) => g(v, a)
           }, [
-            h("input", {
-              id: e.value.toString(),
+            b("input", {
+              id: `option-${i}-${a.value.toString()}`,
               type: "radio",
-              name: t.name,
-              value: e.value,
+              name: e.name,
+              value: a.value,
               class: "maz-hidden",
-              onChange: (s) => l(e)
-            }, null, 40, B),
-            b(a.$slots, "default", {
-              option: e,
-              selected: n(e.value)
+              onChange: (v) => m(a)
+            }, null, 40, M),
+            e.selector ? (r(), s("div", R, [
+              b(
+                "span",
+                {
+                  class: c({
+                    "--is-selected": o(a.value)
+                  }),
+                  style: p([
+                    o(a.value) ? { backgroundColor: `var(--maz-color-${n.color}-600)` } : {}
+                  ])
+                },
+                [
+                  h(
+                    S,
+                    {
+                      name: "maz-radio-buttons-scale",
+                      persisted: ""
+                    },
+                    {
+                      default: $(() => [
+                        C(h(
+                          w(t),
+                          { class: "maz-h-full maz-w-full" },
+                          null,
+                          512
+                          /* NEED_PATCH */
+                        ), [
+                          [V, o(a.value)]
+                        ])
+                      ]),
+                      _: 2
+                      /* DYNAMIC */
+                    },
+                    1024
+                    /* DYNAMIC_SLOTS */
+                  )
+                ],
+                6
+                /* CLASS, STYLE */
+              )
+            ])) : y("v-if", !0),
+            y(`
+        @slot Label of the radio
+          @binding {Boolean} selected - If the option is selected
+          @binding {string | number | boolean} option - The value of the option
+      `),
+            N(e.$slots, "default", {
+              option: a,
+              selected: o(a.value)
             }, () => [
-              k(
-                p(e.label),
+              q(
+                D(a.label),
                 1
                 /* TEXT */
               )
             ], !0)
-          ], 46, x))),
+          ], 46, I))),
           128
           /* KEYED_FRAGMENT */
         ))
@@ -82,12 +134,12 @@ const x = ["for", "aria-checked", "onKeydown"], B = ["id", "name", "value", "onC
       /* CLASS */
     ));
   }
-}), C = (t, r) => {
-  const o = t.__vccOpts || t;
-  for (const [d, l] of r)
-    o[d] = l;
-  return o;
-}, E = /* @__PURE__ */ C(w, [["__scopeId", "data-v-c6249f79"]]);
+}), E = (l, u) => {
+  const t = l.__vccOpts || l;
+  for (const [n, d] of u)
+    t[n] = d;
+  return t;
+}, L = /* @__PURE__ */ E(T, [["__scopeId", "data-v-7f9271c8"]]);
 export {
-  E as default
+  L as default
 };

package/components/MazSelect.d.ts

@@ -1,4 +1,4 @@
-import { type StyleValue } from 'vue';
+import { type HTMLAttributes } from 'vue';
 import type { Color, ModelValueSimple, Position, Size } from './types';
 export type NormalizedOption = Record<string, ModelValueSimple>;
 export type MazSelectOptionWithOptGroup = {
@@ -8,10 +8,10 @@ export type MazSelectOptionWithOptGroup = {
 export type MazSelectOption = NormalizedOption | string | number | boolean | MazSelectOptionWithOptGroup;
 export type { Color, Size, ModelValueSimple, Position };
 export type Props = {
-    /** The style of the select */
-    style?: StyleValue;
-    /** The class of the select */
-    class?: any;
+    /** Style attribut of the component root element */
+    style?: HTMLAttributes['style'];
+    /** Class attribut of the component root element */
+    class?: HTMLAttributes['class'];
     /** The id of the select */
     id?: string;
     /** The value of the select */
@@ -51,6 +51,8 @@ export type Props = {
     /** The input will be displayed in full width */
     block?: boolean;
 };
+declare function closeList(event?: Event): Promise<void>;
+declare function openList(event?: Event): Promise<void>;
 declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<Props>, {
     id: undefined;
     class: undefined;
@@ -67,7 +69,10 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__
     color: string;
     searchPlaceholder: string;
     options: undefined;
-}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+}>, {
+    openList: typeof openList;
+    closeList: typeof closeList;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     close: (value?: Event | undefined) => void;
     open: (value?: boolean | undefined) => void;
     blur: (value?: Event | undefined) => void;
@@ -101,7 +106,7 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__
     "onSelected-option"?: ((option: MazSelectOption) => any) | undefined;
 }, {
     size: Size;
-    style: string | false | import("vue").CSSProperties | StyleValue[] | null;
+    style: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
     id: string;
     options: MazSelectOption[];
     color: Color;

package/components/MazSelect.mjs

@@ -1,4 +1,4 @@
-import { M as f } from "./chunks/MazSelect-DZeXglR8.mjs";
+import { M as f } from "./chunks/MazSelect-Cc8JAFML.mjs";
 export {
   f as default
 };