@scalar/components 0.12.53 → 0.12.54

package/dist/components/ScalarListbox/ScalarListbox.vue.js

@@ -1,9 +1,9 @@
-import { defineComponent as y, openBlock as s, createBlock as d, unref as t, normalizeClass as o, withCtx as a, createTextVNode as g, toDisplayString as m, createCommentVNode as v, createVNode as r, mergeProps as x, createElementBlock as h, Fragment as V, renderList as k, createElementVNode as i, renderSlot as B } from "vue";
+import { defineComponent as y, openBlock as r, createBlock as u, unref as t, normalizeClass as o, withCtx as a, createTextVNode as g, toDisplayString as m, createCommentVNode as v, createVNode as i, mergeProps as x, createElementBlock as V, Fragment as k, renderList as B, createElementVNode as n, renderSlot as h } from "vue";
 import { Listbox as z, ListboxLabel as L, ListboxOptions as w, ListboxOption as O, ListboxButton as C } from "@headlessui/vue";
 import { cva as S, cx as N } from "../../cva.js";
 import $ from "../ScalarFloating/ScalarFloating.vue.js";
 import j from "../ScalarIcon/ScalarIcon.vue.js";
-const E = /* @__PURE__ */ i("div", { class: "absolute inset-0 -z-1 rounded bg-b-1 shadow-md brightness-lifted" }, null, -1), P = /* @__PURE__ */ y({
+const P = /* @__PURE__ */ y({
   inheritAttrs: !1,
   __name: "ScalarListbox",
   props: {
@@ -19,8 +19,8 @@ const E = /* @__PURE__ */ i("div", { class: "absolute inset-0 -z-1 rounded bg-b-
     teleport: { type: [Boolean, String] }
   },
   emits: ["update:modelValue"],
-  setup(W) {
-    const c = S({
+  setup(E) {
+    const f = S({
       base: [
         // Layout
         "group",
@@ -37,15 +37,15 @@ const E = /* @__PURE__ */ i("div", { class: "absolute inset-0 -z-1 rounded bg-b-
         disabled: { true: "pointer-events-none opacity-50" }
       }
     });
-    return (e, u) => (s(), d(t(z), {
+    return (e, s) => (r(), u(t(z), {
       as: "div",
       class: o([{ "w-full": e.fullWidth }, "text-sm"]),
       modelValue: e.modelValue,
       multiple: e.multiple,
-      "onUpdate:modelValue": u[0] || (u[0] = (n) => e.$emit("update:modelValue", n))
+      "onUpdate:modelValue": s[0] || (s[0] = (d) => e.$emit("update:modelValue", d))
     }, {
-      default: a(({ open: n }) => [
-        e.label ? (s(), d(t(L), {
+      default: a(({ open: d }) => [
+        e.label ? (r(), u(t(L), {
           key: 0,
           class: "sr-only"
         }, {
@@ -54,59 +54,59 @@ const E = /* @__PURE__ */ i("div", { class: "absolute inset-0 -z-1 rounded bg-b-
           ]),
           _: 1
         })) : v("", !0),
-        r(t($), {
-          isOpen: n ?? e.isOpen,
+        i(t($), {
+          isOpen: d ?? e.isOpen,
           placement: e.placement ?? "bottom-start",
           resize: e.resize,
           teleport: e.teleport
         }, {
-          floating: a(({ width: f }) => [
-            r(t(w), x({
+          floating: a(({ width: b }) => [
+            i(t(w), x({
               class: "relative flex w-40 flex-col rounded border p-0.75",
-              style: { width: f }
+              style: { width: b }
             }, e.$attrs), {
               default: a(() => [
-                (s(!0), h(V, null, k(e.options, (l) => (s(), d(t(O), {
+                (r(!0), V(k, null, B(e.options, (l) => (r(), u(t(O), {
                   key: l.id,
                   as: "template",
                   disabled: l.disabled,
                   value: l
                 }, {
-                  default: a(({ active: b, selected: p }) => [
-                    i("li", {
+                  default: a(({ active: c, selected: p }) => [
+                    n("li", {
                       class: o(
-                        t(N)(t(c)({ active: b, selected: p, disabled: l.disabled }))
+                        t(N)(t(f)({ active: c, selected: p, disabled: l.disabled }))
                       )
                     }, [
-                      i("div", {
+                      n("div", {
                         class: o(["flex size-4 items-center justify-center rounded-full p-[3px] group-hover:shadow-border", p ? "bg-blue text-b-1" : "text-transparent"])
                       }, [
-                        r(t(j), {
+                        i(t(j), {
                           class: "relative top-[0.5px] size-2.5",
                           icon: "Checkmark",
                           thickness: "2.5"
                         })
                       ], 2),
-                      i("span", {
+                      n("span", {
                         class: o(["inline-block min-w-0 flex-1 truncate", l.color ? l.color : "text-c-1"])
                       }, m(l.label), 3)
                     ], 2)
                   ]),
                   _: 2
                 }, 1032, ["disabled", "value"]))), 128)),
-                E
+                s[1] || (s[1] = n("div", { class: "absolute inset-0 -z-1 rounded bg-b-1 shadow-md brightness-lifted" }, null, -1))
               ]),
               _: 2
             }, 1040, ["style"])
           ]),
           default: a(() => [
-            r(t(C), {
+            i(t(C), {
               id: e.id,
               as: "template",
               class: "justify-start focus:outline-none focus-visible:ring-1 focus-visible:ring-c-accent"
             }, {
               default: a(() => [
-                B(e.$slots, "default")
+                h(e.$slots, "default")
               ]),
               _: 3
             }, 8, ["id"])

package/dist/components/ScalarLoading/ScalarLoading.stories.d.ts

@@ -4,200 +4,65 @@ import type { StoryObj } from '@storybook/vue3';
  */
 declare const meta: {
     component: import("vue").DefineComponent<{
-        loadingState: {
-            type: import("vue").PropType<{
-                isValid: boolean;
-                isInvalid: boolean;
-                isLoading: boolean;
-                startLoading: () => void;
-                stopLoading: () => void;
-                validate: (time?: number, clear?: boolean) => Promise<unknown>;
-                invalidate: (time?: number, clear?: boolean) => Promise<unknown>;
-                clear: (time?: number) => Promise<unknown>;
-            }>;
-            required: true;
-        };
-        size: {
-            type: import("vue").PropType<"xs" | "sm" | "md" | "lg" | "xl" | "2xl" | "3xl" | "full">;
-        };
-    }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-        loadingState: {
-            type: import("vue").PropType<{
-                isValid: boolean;
-                isInvalid: boolean;
-                isLoading: boolean;
-                startLoading: () => void;
-                stopLoading: () => void;
-                validate: (time?: number, clear?: boolean) => Promise<unknown>;
-                invalidate: (time?: number, clear?: boolean) => Promise<unknown>;
-                clear: (time?: number) => Promise<unknown>;
-            }>;
-            required: true;
-        };
-        size: {
-            type: import("vue").PropType<"xs" | "sm" | "md" | "lg" | "xl" | "2xl" | "3xl" | "full">;
-        };
-    }>>, {}, {}>;
+        loadingState: import("./ScalarLoading.vue.js").LoadingState;
+        size?: "xs" | "sm" | "md" | "lg" | "xl" | "2xl" | "3xl" | "full" | undefined;
+    }, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+        loadingState: import("./ScalarLoading.vue.js").LoadingState;
+        size?: "xs" | "sm" | "md" | "lg" | "xl" | "2xl" | "3xl" | "full" | undefined;
+    }> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
     tags: string[];
     argTypes: {};
     render: () => {
         components: {
             ScalarButton: {
-                new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
-                    size: {
-                        type: import("vue").PropType<"sm" | "md">;
-                        default: string;
-                    };
-                    type: {
-                        type: import("vue").PropType<"button" | "submit" | "reset">;
-                        default: string;
-                    };
-                    variant: {
-                        type: import("vue").PropType<string>;
-                        default: string;
-                    };
-                    disabled: {
-                        type: import("vue").PropType<boolean>;
-                    };
-                    fullWidth: {
-                        type: import("vue").PropType<boolean>;
-                        default: boolean;
-                    };
-                    loading: {
-                        type: import("vue").PropType<{
-                            isValid: boolean;
-                            isInvalid: boolean;
-                            isLoading: boolean;
-                            startLoading: () => void;
-                            stopLoading: () => void;
-                            validate: (time?: number, clear?: boolean) => Promise<unknown>;
-                            invalidate: (time?: number, clear?: boolean) => Promise<unknown>;
-                            clear: (time?: number) => Promise<unknown>;
-                        }>;
-                    };
-                }>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
-                    size: {
-                        type: import("vue").PropType<"sm" | "md">;
-                        default: string;
-                    };
-                    type: {
-                        type: import("vue").PropType<"button" | "submit" | "reset">;
-                        default: string;
-                    };
-                    variant: {
-                        type: import("vue").PropType<string>;
-                        default: string;
-                    };
-                    disabled: {
-                        type: import("vue").PropType<boolean>;
-                    };
-                    fullWidth: {
-                        type: import("vue").PropType<boolean>;
-                        default: boolean;
-                    };
-                    loading: {
-                        type: import("vue").PropType<{
-                            isValid: boolean;
-                            isInvalid: boolean;
-                            isLoading: boolean;
-                            startLoading: () => void;
-                            stopLoading: () => void;
-                            validate: (time?: number, clear?: boolean) => Promise<unknown>;
-                            invalidate: (time?: number, clear?: boolean) => Promise<unknown>;
-                            clear: (time?: number) => Promise<unknown>;
-                        }>;
-                    };
-                }>>, {
+                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
+                    disabled?: boolean;
+                    fullWidth?: boolean;
+                    loading?: import("./ScalarLoading.vue.js").LoadingState;
+                    size?: import("../ScalarButton/variants.js").Variants["size"];
+                    variant?: import("../ScalarButton/variants.js").Variants["variant"];
+                    type?: "button" | "submit" | "reset";
+                }> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
                     size: "sm" | "md";
-                    type: "button" | "submit" | "reset";
                     variant: string;
                     fullWidth: boolean;
-                }, true, {}, {}, {
+                    type: "button" | "submit" | "reset";
+                }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                     P: {};
                     B: {};
                     D: {};
                     C: {};
                     M: {};
                     Defaults: {};
-                }, Readonly<import("vue").ExtractPropTypes<{
-                    size: {
-                        type: import("vue").PropType<"sm" | "md">;
-                        default: string;
-                    };
-                    type: {
-                        type: import("vue").PropType<"button" | "submit" | "reset">;
-                        default: string;
-                    };
-                    variant: {
-                        type: import("vue").PropType<string>;
-                        default: string;
-                    };
-                    disabled: {
-                        type: import("vue").PropType<boolean>;
-                    };
-                    fullWidth: {
-                        type: import("vue").PropType<boolean>;
-                        default: boolean;
-                    };
-                    loading: {
-                        type: import("vue").PropType<{
-                            isValid: boolean;
-                            isInvalid: boolean;
-                            isLoading: boolean;
-                            startLoading: () => void;
-                            stopLoading: () => void;
-                            validate: (time?: number, clear?: boolean) => Promise<unknown>;
-                            invalidate: (time?: number, clear?: boolean) => Promise<unknown>;
-                            clear: (time?: number) => Promise<unknown>;
-                        }>;
-                    };
-                }>>, {}, {}, {}, {}, {
+                }, Readonly<{
+                    disabled?: boolean;
+                    fullWidth?: boolean;
+                    loading?: import("./ScalarLoading.vue.js").LoadingState;
+                    size?: import("../ScalarButton/variants.js").Variants["size"];
+                    variant?: import("../ScalarButton/variants.js").Variants["variant"];
+                    type?: "button" | "submit" | "reset";
+                }> & Readonly<{}>, {}, {}, {}, {}, {
                     size: "sm" | "md";
-                    type: "button" | "submit" | "reset";
                     variant: string;
                     fullWidth: boolean;
+                    type: "button" | "submit" | "reset";
                 }>;
                 __isFragment?: never;
                 __isTeleport?: never;
                 __isSuspense?: never;
-            } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-                size: {
-                    type: import("vue").PropType<"sm" | "md">;
-                    default: string;
-                };
-                type: {
-                    type: import("vue").PropType<"button" | "submit" | "reset">;
-                    default: string;
-                };
-                variant: {
-                    type: import("vue").PropType<string>;
-                    default: string;
-                };
-                disabled: {
-                    type: import("vue").PropType<boolean>;
-                };
-                fullWidth: {
-                    type: import("vue").PropType<boolean>;
-                    default: boolean;
-                };
-                loading: {
-                    type: import("vue").PropType<{
-                        isValid: boolean;
-                        isInvalid: boolean;
-                        isLoading: boolean;
-                        startLoading: () => void;
-                        stopLoading: () => void;
-                        validate: (time?: number, clear?: boolean) => Promise<unknown>;
-                        invalidate: (time?: number, clear?: boolean) => Promise<unknown>;
-                        clear: (time?: number) => Promise<unknown>;
-                    }>;
-                };
-            }>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+            } & import("vue").ComponentOptionsBase<Readonly<{
+                disabled?: boolean;
+                fullWidth?: boolean;
+                loading?: import("./ScalarLoading.vue.js").LoadingState;
+                size?: import("../ScalarButton/variants.js").Variants["size"];
+                variant?: import("../ScalarButton/variants.js").Variants["variant"];
+                type?: "button" | "submit" | "reset";
+            }> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
                 size: "sm" | "md";
-                type: "button" | "submit" | "reset";
                 variant: string;
                 fullWidth: boolean;
-            }, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+                type: "button" | "submit" | "reset";
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
                 $slots: {
                     icon?(_: {}): any;
                     default?(_: {}): any;
@@ -205,40 +70,12 @@ declare const meta: {
                 };
             });
             ScalarLoading: import("vue").DefineComponent<{
-                loadingState: {
-                    type: import("vue").PropType<{
-                        isValid: boolean;
-                        isInvalid: boolean;
-                        isLoading: boolean;
-                        startLoading: () => void;
-                        stopLoading: () => void;
-                        validate: (time?: number, clear?: boolean) => Promise<unknown>;
-                        invalidate: (time?: number, clear?: boolean) => Promise<unknown>;
-                        clear: (time?: number) => Promise<unknown>;
-                    }>;
-                    required: true;
-                };
-                size: {
-                    type: import("vue").PropType<"xs" | "sm" | "md" | "lg" | "xl" | "2xl" | "3xl" | "full">;
-                };
-            }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-                loadingState: {
-                    type: import("vue").PropType<{
-                        isValid: boolean;
-                        isInvalid: boolean;
-                        isLoading: boolean;
-                        startLoading: () => void;
-                        stopLoading: () => void;
-                        validate: (time?: number, clear?: boolean) => Promise<unknown>;
-                        invalidate: (time?: number, clear?: boolean) => Promise<unknown>;
-                        clear: (time?: number) => Promise<unknown>;
-                    }>;
-                    required: true;
-                };
-                size: {
-                    type: import("vue").PropType<"xs" | "sm" | "md" | "lg" | "xl" | "2xl" | "3xl" | "full">;
-                };
-            }>>, {}, {}>;
+                loadingState: import("./ScalarLoading.vue.js").LoadingState;
+                size?: "xs" | "sm" | "md" | "lg" | "xl" | "2xl" | "3xl" | "full" | undefined;
+            }, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+                loadingState: import("./ScalarLoading.vue.js").LoadingState;
+                size?: "xs" | "sm" | "md" | "lg" | "xl" | "2xl" | "3xl" | "full" | undefined;
+            }> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
         };
         setup(this: void): {
             loadingState: {

package/dist/components/ScalarLoading/ScalarLoading.stories.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ScalarLoading.stories.d.ts","sourceRoot":"","sources":["../../../src/components/ScalarLoading/ScalarLoading.stories.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAQ,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAKrD;;GAEG;AACH,QAAA,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsB4B,CAAA;AAEtC,eAAe,IAAI,CAAA;AACnB,KAAK,KAAK,GAAG,QAAQ,CAAC,OAAO,IAAI,CAAC,CAAA;AAElC,eAAO,MAAM,IAAI,EAAE,KAAiB,CAAA"}
+{"version":3,"file":"ScalarLoading.stories.d.ts","sourceRoot":"","sources":["../../../src/components/ScalarLoading/ScalarLoading.stories.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAQ,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAKrD;;GAEG;AACH,QAAA,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsB4B,CAAA;AAEtC,eAAe,IAAI,CAAA;AACnB,KAAK,KAAK,GAAG,QAAQ,CAAC,OAAO,IAAI,CAAC,CAAA;AAElC,eAAO,MAAM,IAAI,EAAE,KAAiB,CAAA"}

package/dist/components/ScalarLoading/ScalarLoading.vue.d.ts

@@ -14,21 +14,12 @@ export declare function useLoadingState(): {
     invalidate: (time?: number, clear?: boolean) => Promise<unknown>;
     clear: (time?: number) => Promise<unknown>;
 };
-declare const _default: import("vue").DefineComponent<__VLS_TypePropsToOption<{
+declare const _default: import("vue").DefineComponent<{
     loadingState: LoadingState;
     size?: "xs" | "sm" | "md" | "lg" | "xl" | "2xl" | "3xl" | "full" | undefined;
-}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<{
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
     loadingState: LoadingState;
     size?: "xs" | "sm" | "md" | "lg" | "xl" | "2xl" | "3xl" | "full" | undefined;
-}>>>, {}, {}>;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;
-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;
-    };
-};
 //# sourceMappingURL=ScalarLoading.vue.d.ts.map

package/dist/components/ScalarLoading/ScalarLoading.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ScalarLoading.vue.d.ts","sourceRoot":"","sources":["../../../src/components/ScalarLoading/ScalarLoading.vue"],"names":[],"mappings":"AA2OA,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,eAAe,CAAC,CAAA;AAE7D;;;;GAIG;AACH,wBAAgB,eAAe;;;;;;sCAWE,OAAO;wCAWJ,OAAO;;EAuB1C;;kBAMe,YAAY;;;kBAAZ,YAAY;;;AAL5B,wBA+HK;AAML,KAAK,sBAAsB,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,GAAG,KAAK,GAAG,CAAC,CAAC;AAC5D,KAAK,uBAAuB,CAAC,CAAC,IAAI;KAChC,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,EAAE,SAAS,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GACpC;QAAE,IAAI,EAAE,OAAO,KAAK,EAAE,QAAQ,CAAC,sBAAsB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;KAAE,GAC9D;QAAE,IAAI,EAAE,OAAO,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAAC,QAAQ,EAAE,IAAI,CAAA;KAAE;CACzD,CAAC"}
+{"version":3,"file":"ScalarLoading.vue.d.ts","sourceRoot":"","sources":["../../../src/components/ScalarLoading/ScalarLoading.vue"],"names":[],"mappings":"AA2OA,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,eAAe,CAAC,CAAA;AAE7D;;;;GAIG;AACH,wBAAgB,eAAe;;;;;;sCAWE,OAAO;wCAWJ,OAAO;;EAuB1C;;kBAMe,YAAY;;;kBAAZ,YAAY;;;AAL5B,wBA+HK"}

package/dist/components/ScalarLoading/ScalarLoading.vue2.js

@@ -1,11 +1,11 @@
-import { defineComponent as d, openBlock as i, createElementBlock as l, normalizeClass as n, unref as o, createElementVNode as h, createCommentVNode as r, createStaticVNode as c, reactive as v } from "vue";
-import { cva as g, cx as m } from "../../cva.js";
-const p = /* @__PURE__ */ c('<path class="svg-path svg-check-mark" d="m 0 60 l 30 30 l 70 -80" data-v-5a129980></path><path class="svg-path svg-x-mark" d="m 50 50 l 40 -40" data-v-5a129980></path><path class="svg-path svg-x-mark" d="m 50 50 l 40 40" data-v-5a129980></path><path class="svg-path svg-x-mark" d="m 50 50 l -40 -40" data-v-5a129980></path><path class="svg-path svg-x-mark" d="m 50 50 l -40 40" data-v-5a129980></path>', 5), u = {
+import { defineComponent as d, openBlock as e, createElementBlock as l, normalizeClass as n, unref as o, createStaticVNode as h, createElementVNode as v, createCommentVNode as r, reactive as g } from "vue";
+import { cva as m, cx as p } from "../../cva.js";
+const u = {
   key: 0,
   class: "circular-loader"
 };
-function z() {
-  return v({
+function w() {
+  return g({
     isValid: !1,
     isInvalid: !1,
     isLoading: !1,
@@ -15,37 +15,37 @@ function z() {
     stopLoading() {
       this.isLoading = !1;
     },
-    validate(e = 800, s) {
+    validate(i = 800, s) {
       this.isInvalid = !1, this.isValid = !0;
-      const a = s ? e - 300 : e;
+      const a = s ? i - 300 : i;
       return new Promise(
         (t) => setTimeout(s ? () => this.clear().then(() => t(!0)) : () => t(!0), a)
       );
     },
-    invalidate(e = 1100, s) {
+    invalidate(i = 1100, s) {
       this.isValid = !1, this.isInvalid = !0;
-      const a = s ? e - 300 : e;
+      const a = s ? i - 300 : i;
       return new Promise(
         (t) => setTimeout(s ? () => this.clear().then(() => t(!0)) : () => t(!0), a)
       );
     },
-    clear(e = 300) {
+    clear(i = 300) {
       return this.isValid = !1, this.isInvalid = !1, this.isLoading = !1, new Promise((s) => {
         setTimeout(() => {
           s(!0);
-        }, e);
+        }, i);
       });
     }
   });
 }
-const k = /* @__PURE__ */ d({
+const z = /* @__PURE__ */ d({
   __name: "ScalarLoading",
   props: {
     loadingState: {},
     size: {}
   },
-  setup(e) {
-    const s = g({
+  setup(i) {
+    const s = m({
       variants: {
         size: {
           xs: "size-3",
@@ -62,11 +62,11 @@ const k = /* @__PURE__ */ d({
         size: "full"
       }
     });
-    return (a, t) => a.loadingState ? (i(), l("div", {
+    return (a, t) => a.loadingState ? (e(), l("div", {
       key: 0,
-      class: n(o(m)("loader-wrapper", o(s)({ size: a.size })))
+      class: n(o(p)("loader-wrapper", o(s)({ size: a.size })))
     }, [
-      (i(), l("svg", {
+      (e(), l("svg", {
         class: n(["svg-loader", {
           "icon-is-valid": a.loadingState.isValid,
           "icon-is-invalid": a.loadingState.isInvalid
@@ -75,9 +75,9 @@ const k = /* @__PURE__ */ d({
         xmlns: "http://www.w3.org/2000/svg",
         "xmlns:xlink": "http://www.w3.org/1999/xlink"
       }, [
-        p,
-        a.loadingState.isLoading ? (i(), l("g", u, [
-          h("circle", {
+        t[0] || (t[0] = h('<path class="svg-path svg-check-mark" d="m 0 60 l 30 30 l 70 -80" data-v-5a129980></path><path class="svg-path svg-x-mark" d="m 50 50 l 40 -40" data-v-5a129980></path><path class="svg-path svg-x-mark" d="m 50 50 l 40 40" data-v-5a129980></path><path class="svg-path svg-x-mark" d="m 50 50 l -40 -40" data-v-5a129980></path><path class="svg-path svg-x-mark" d="m 50 50 l -40 40" data-v-5a129980></path>', 5)),
+        a.loadingState.isLoading ? (e(), l("g", u, [
+          v("circle", {
             class: n(["loader-path", {
               "loader-path-off": a.loadingState.isValid || a.loadingState.isInvalid
             }]),
@@ -93,6 +93,6 @@ const k = /* @__PURE__ */ d({
   }
 });
 export {
-  k as default,
-  z as useLoadingState
+  z as default,
+  w as useLoadingState
 };