@scalar/components 0.13.20 → 0.13.23

package/dist/components/ScalarCombobox/ScalarComboboxPopover.vue.js

@@ -1,8 +1,9 @@
-import { defineComponent as m, ref as c, openBlock as v, createBlock as y, unref as t, withCtx as r, createVNode as l, normalizeProps as w, guardReactiveProps as _, createSlots as b, renderSlot as s, mergeProps as g, createElementVNode as B } from "vue";
-import { Popover as P, PopoverButton as k, PopoverPanel as x } from "@headlessui/vue";
-import { useBindCx as h } from "../../hooks/useBindCx.js";
-import C from "../ScalarFloating/ScalarFloating.vue.js";
-const K = /* @__PURE__ */ m({
+import { defineComponent as u, ref as c, openBlock as _, createBlock as v, unref as o, withCtx as t, createVNode as r, normalizeProps as y, guardReactiveProps as w, createSlots as x, renderSlot as l, mergeProps as B } from "vue";
+import { Popover as P, PopoverButton as h, PopoverPanel as k } from "@headlessui/vue";
+import { useBindCx as g } from "../../hooks/useBindCx.js";
+import $ from "../ScalarFloating/ScalarFloating.vue.js";
+import C from "../ScalarFloating/ScalarFloatingBackdrop.vue.js";
+const z = /* @__PURE__ */ u({
   inheritAttrs: !1,
   __name: "ScalarComboboxPopover",
   props: {
@@ -13,42 +14,45 @@ const K = /* @__PURE__ */ m({
     middleware: {},
     teleport: { type: [Boolean, String] }
   },
-  setup(E, { expose: p }) {
-    const { cx: d } = h(), a = c(null), f = (e) => {
-      var o;
-      ["ArrowUp", "ArrowDown"].includes(e.key) && (e.preventDefault(), (o = e.target) == null || o.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter" })));
+  setup(S, { expose: s }) {
+    const { cx: f } = g(), p = c(null), i = (e) => {
+      var n;
+      ["ArrowUp", "ArrowDown"].includes(e.key) && (e.preventDefault(), (n = e.target) == null || n.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter" })));
     };
-    return p({ popoverButtonRef: a }), (e, o) => (v(), y(t(P), { as: "template" }, {
-      default: r(({ open: n }) => [
-        l(t(C), w(_(e.$props)), b({
-          default: r(() => [
-            l(t(k), {
+    return s({ popoverButtonRef: p }), (e, n) => (_(), v(o(P), { as: "template" }, {
+      default: t(({ open: a }) => [
+        r(o($), y(w(e.$props)), x({
+          default: t(() => [
+            r(o(h), {
               ref_key: "popoverButtonRef",
-              ref: a,
+              ref: p,
               as: "template",
-              onKeydown: f
+              onKeydown: i
             }, {
-              default: r(() => [
-                s(e.$slots, "default", { open: n })
+              default: t(() => [
+                l(e.$slots, "default", { open: a })
               ]),
               _: 2
             }, 1536)
           ]),
           _: 2
         }, [
-          n ? {
+          a ? {
             name: "floating",
-            fn: r(({ width: i }) => [
-              l(t(x), g({
-                focus: "",
-                style: { width: i }
-              }, t(d)("relative flex w-40 flex-col rounded border text-sm")), {
-                default: r(({ close: u }) => [
-                  s(e.$slots, "popover", {
-                    close: u,
-                    open: n
+            fn: t(({ width: m }) => [
+              r(o(k), B(
+                {
+                  focus: "",
+                  style: { width: m }
+                },
+                o(f)("relative flex flex-col max-h-[inherit] w-40 rounded text-sm")
+              ), {
+                default: t(({ close: d }) => [
+                  l(e.$slots, "popover", {
+                    close: d,
+                    open: a
                   }),
-                  o[0] || (o[0] = B("div", { class: "absolute inset-0 -z-1 rounded bg-b-1 shadow-md brightness-lifted" }, null, -1))
+                  r(o(C))
                 ]),
                 _: 2
               }, 1040, ["style"])
@@ -62,5 +66,5 @@ const K = /* @__PURE__ */ m({
   }
 });
 export {
-  K as default
+  z as default
 };

package/dist/components/ScalarCombobox/types.d.ts

@@ -12,4 +12,13 @@ export type OptionGroup = {
 export declare function isGroup(option: Option | OptionGroup): option is OptionGroup;
 /** Type guard to check if an array of options is an array of groups */
 export declare function isGroups(options: Option[] | OptionGroup[]): options is OptionGroup[];
+/** Available slots for the combobox */
+export type ComboboxSlots = {
+    /** The reference element / trigger for the combobox */
+    default(): any;
+    /** A slot for contents before the combobox options */
+    before?(): any;
+    /** A slot for contents after the combobox options */
+    after?(): any;
+};
 //# sourceMappingURL=types.d.ts.map

package/dist/components/ScalarCombobox/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/components/ScalarCombobox/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,MAAM,GAAG;IACnB,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,CAAC,CAAC,EAAE,MAAM,GAAG,GAAG,CAAA;CACjB,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,EAAE,CAAA;CAClB,CAAA;AAED,kDAAkD;AAClD,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,GAAG,MAAM,IAAI,WAAW,CAE3E;AAED,uEAAuE;AACvE,wBAAgB,QAAQ,CACtB,OAAO,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,GAChC,OAAO,IAAI,WAAW,EAAE,CAE1B"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/components/ScalarCombobox/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,MAAM,GAAG;IACnB,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,CAAC,CAAC,EAAE,MAAM,GAAG,GAAG,CAAA;CACjB,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,EAAE,CAAA;CAClB,CAAA;AAED,kDAAkD;AAClD,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,GAAG,MAAM,IAAI,WAAW,CAE3E;AAED,uEAAuE;AACvE,wBAAgB,QAAQ,CACtB,OAAO,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,GAChC,OAAO,IAAI,WAAW,EAAE,CAE1B;AAED,uCAAuC;AACvC,MAAM,MAAM,aAAa,GAAG;IAC1B,uDAAuD;IACvD,OAAO,IAAI,GAAG,CAAA;IACd,sDAAsD;IACtD,MAAM,CAAC,IAAI,GAAG,CAAA;IACd,qDAAqD;IACrD,KAAK,CAAC,IAAI,GAAG,CAAA;CACd,CAAA"}

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

@@ -162,7 +162,7 @@ declare const meta: {
                 new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
                     disabled?: boolean;
                     fullWidth?: boolean;
-                    loading?: import("../ScalarLoading").LoadingState;
+                    loading?: import("../ScalarLoading").LoadingState | undefined;
                     size?: import("../ScalarButton/variants.js").Variants["size"];
                     variant?: import("../ScalarButton/variants.js").Variants["variant"];
                     type?: "button" | "submit" | "reset";
@@ -181,7 +181,7 @@ declare const meta: {
                 }, Readonly<{
                     disabled?: boolean;
                     fullWidth?: boolean;
-                    loading?: import("../ScalarLoading").LoadingState;
+                    loading?: import("../ScalarLoading").LoadingState | undefined;
                     size?: import("../ScalarButton/variants.js").Variants["size"];
                     variant?: import("../ScalarButton/variants.js").Variants["variant"];
                     type?: "button" | "submit" | "reset";
@@ -197,7 +197,7 @@ declare const meta: {
             } & import("vue").ComponentOptionsBase<Readonly<{
                 disabled?: boolean;
                 fullWidth?: boolean;
-                loading?: import("../ScalarLoading").LoadingState;
+                loading?: import("../ScalarLoading").LoadingState | undefined;
                 size?: import("../ScalarButton/variants.js").Variants["size"];
                 variant?: import("../ScalarButton/variants.js").Variants["variant"];
                 type?: "button" | "submit" | "reset";

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

@@ -139,7 +139,7 @@ declare const meta: {
                 new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
                     disabled?: boolean;
                     fullWidth?: boolean;
-                    loading?: import("../ScalarLoading").LoadingState;
+                    loading?: import("../ScalarLoading").LoadingState | undefined;
                     size?: import("../ScalarButton/variants.js").Variants["size"];
                     variant?: import("../ScalarButton/variants.js").Variants["variant"];
                     type?: "button" | "submit" | "reset";
@@ -158,7 +158,7 @@ declare const meta: {
                 }, Readonly<{
                     disabled?: boolean;
                     fullWidth?: boolean;
-                    loading?: import("../ScalarLoading").LoadingState;
+                    loading?: import("../ScalarLoading").LoadingState | undefined;
                     size?: import("../ScalarButton/variants.js").Variants["size"];
                     variant?: import("../ScalarButton/variants.js").Variants["variant"];
                     type?: "button" | "submit" | "reset";
@@ -174,7 +174,7 @@ declare const meta: {
             } & import("vue").ComponentOptionsBase<Readonly<{
                 disabled?: boolean;
                 fullWidth?: boolean;
-                loading?: import("../ScalarLoading").LoadingState;
+                loading?: import("../ScalarLoading").LoadingState | undefined;
                 size?: import("../ScalarButton/variants.js").Variants["size"];
                 variant?: import("../ScalarButton/variants.js").Variants["variant"];
                 type?: "button" | "submit" | "reset";

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

@@ -0,0 +1,364 @@
+import type { StoryObj } from '@storybook/vue3';
+declare const meta: {
+    component: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
+            modelValue?: File[];
+            error?: string;
+        } & {
+            multiple?: boolean;
+            accept?: import("./types").ExtensionList | string;
+            loader?: import("../ScalarLoading").LoadingState;
+            variant?: "compact" | "default";
+        }> & Readonly<{
+            "onUpdate:modelValue"?: ((value: File[]) => any) | undefined;
+            onSelected?: ((value: File[]) => any) | undefined;
+            "onUpdate:error"?: ((value: string) => any) | undefined;
+        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            "update:modelValue": (value: File[]) => any;
+            "update:error": (value: string) => any;
+        } & {
+            selected: (value: File[]) => any;
+        }, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<{
+            modelValue?: File[];
+            error?: string;
+        } & {
+            multiple?: boolean;
+            accept?: import("./types").ExtensionList | string;
+            loader?: import("../ScalarLoading").LoadingState;
+            variant?: "compact" | "default";
+        }> & Readonly<{
+            "onUpdate:modelValue"?: ((value: File[]) => any) | undefined;
+            onSelected?: ((value: File[]) => any) | undefined;
+            "onUpdate:error"?: ((value: string) => any) | undefined;
+        }>, {}, {}, {}, {}, {}>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<{
+        modelValue?: File[];
+        error?: string;
+    } & {
+        multiple?: boolean;
+        accept?: import("./types").ExtensionList | string;
+        loader?: import("../ScalarLoading").LoadingState;
+        variant?: "compact" | "default";
+    }> & Readonly<{
+        "onUpdate:modelValue"?: ((value: File[]) => any) | undefined;
+        onSelected?: ((value: File[]) => any) | undefined;
+        "onUpdate:error"?: ((value: string) => any) | undefined;
+    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        "update:modelValue": (value: File[]) => any;
+        "update:error": (value: string) => any;
+    } & {
+        selected: (value: File[]) => any;
+    }, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: Readonly<{
+            default?: (props: {
+                open: () => void;
+            }) => any;
+            label?: () => any;
+            'drop-target'?: () => any;
+            'drop-target-label'?: () => any;
+        }> & {
+            default?: (props: {
+                open: () => void;
+            }) => any;
+            label?: () => any;
+            'drop-target'?: () => any;
+            'drop-target-label'?: () => any;
+        };
+    });
+    tags: string[];
+    argTypes: {
+        class: {
+            control: "text";
+        };
+        accept: {
+            control: "select";
+            options: string[][];
+        };
+        variant: {
+            control: "select";
+            options: string[];
+        };
+    };
+    render: (args: import("@storybook/vue3").ComponentPropsAndSlots<{
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
+            modelValue?: File[];
+            error?: string;
+        } & {
+            multiple?: boolean;
+            accept?: import("./types").ExtensionList | string;
+            loader?: import("../ScalarLoading").LoadingState;
+            variant?: "compact" | "default";
+        }> & Readonly<{
+            "onUpdate:modelValue"?: ((value: File[]) => any) | undefined;
+            onSelected?: ((value: File[]) => any) | undefined;
+            "onUpdate:error"?: ((value: string) => any) | undefined;
+        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            "update:modelValue": (value: File[]) => any;
+            "update:error": (value: string) => any;
+        } & {
+            selected: (value: File[]) => any;
+        }, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<{
+            modelValue?: File[];
+            error?: string;
+        } & {
+            multiple?: boolean;
+            accept?: import("./types").ExtensionList | string;
+            loader?: import("../ScalarLoading").LoadingState;
+            variant?: "compact" | "default";
+        }> & Readonly<{
+            "onUpdate:modelValue"?: ((value: File[]) => any) | undefined;
+            onSelected?: ((value: File[]) => any) | undefined;
+            "onUpdate:error"?: ((value: string) => any) | undefined;
+        }>, {}, {}, {}, {}, {}>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<{
+        modelValue?: File[];
+        error?: string;
+    } & {
+        multiple?: boolean;
+        accept?: import("./types").ExtensionList | string;
+        loader?: import("../ScalarLoading").LoadingState;
+        variant?: "compact" | "default";
+    }> & Readonly<{
+        "onUpdate:modelValue"?: ((value: File[]) => any) | undefined;
+        onSelected?: ((value: File[]) => any) | undefined;
+        "onUpdate:error"?: ((value: string) => any) | undefined;
+    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        "update:modelValue": (value: File[]) => any;
+        "update:error": (value: string) => any;
+    } & {
+        selected: (value: File[]) => any;
+    }, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: Readonly<{
+            default?: (props: {
+                open: () => void;
+            }) => any;
+            label?: () => any;
+            'drop-target'?: () => any;
+            'drop-target-label'?: () => any;
+        }> & {
+            default?: (props: {
+                open: () => void;
+            }) => any;
+            label?: () => any;
+            'drop-target'?: () => any;
+            'drop-target-label'?: () => any;
+        };
+    })>) => {
+        components: {
+            ScalarFileUpload: {
+                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
+                    modelValue?: File[];
+                    error?: string;
+                } & {
+                    multiple?: boolean;
+                    accept?: import("./types").ExtensionList | string;
+                    loader?: import("../ScalarLoading").LoadingState;
+                    variant?: "compact" | "default";
+                }> & Readonly<{
+                    "onUpdate:modelValue"?: ((value: File[]) => any) | undefined;
+                    onSelected?: ((value: File[]) => any) | undefined;
+                    "onUpdate:error"?: ((value: string) => any) | undefined;
+                }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                    "update:modelValue": (value: File[]) => any;
+                    "update:error": (value: string) => any;
+                } & {
+                    selected: (value: File[]) => any;
+                }, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<{
+                    modelValue?: File[];
+                    error?: string;
+                } & {
+                    multiple?: boolean;
+                    accept?: import("./types").ExtensionList | string;
+                    loader?: import("../ScalarLoading").LoadingState;
+                    variant?: "compact" | "default";
+                }> & Readonly<{
+                    "onUpdate:modelValue"?: ((value: File[]) => any) | undefined;
+                    onSelected?: ((value: File[]) => any) | undefined;
+                    "onUpdate:error"?: ((value: string) => any) | undefined;
+                }>, {}, {}, {}, {}, {}>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import("vue").ComponentOptionsBase<Readonly<{
+                modelValue?: File[];
+                error?: string;
+            } & {
+                multiple?: boolean;
+                accept?: import("./types").ExtensionList | string;
+                loader?: import("../ScalarLoading").LoadingState;
+                variant?: "compact" | "default";
+            }> & Readonly<{
+                "onUpdate:modelValue"?: ((value: File[]) => any) | undefined;
+                onSelected?: ((value: File[]) => any) | undefined;
+                "onUpdate:error"?: ((value: string) => any) | undefined;
+            }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                "update:modelValue": (value: File[]) => any;
+                "update:error": (value: string) => any;
+            } & {
+                selected: (value: File[]) => any;
+            }, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+                $slots: Readonly<{
+                    default?: (props: {
+                        open: () => void;
+                    }) => any;
+                    label?: () => any;
+                    'drop-target'?: () => any;
+                    'drop-target-label'?: () => any;
+                }> & {
+                    default?: (props: {
+                        open: () => void;
+                    }) => any;
+                    label?: () => any;
+                    'drop-target'?: () => any;
+                    'drop-target-label'?: () => any;
+                };
+            });
+            ScalarFileUploadFileList: import("vue").DefineComponent<{
+                modelValue?: File[];
+            }, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                "update:modelValue": (value: File[]) => any;
+            } & {
+                upload: () => any;
+            }, string, import("vue").PublicProps, Readonly<{
+                modelValue?: File[];
+            }> & Readonly<{
+                "onUpdate:modelValue"?: ((value: File[]) => any) | undefined;
+                onUpload?: (() => any) | undefined;
+            }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+        };
+        setup(this: void): {
+            args: import("@storybook/vue3").ComponentPropsAndSlots<{
+                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
+                    modelValue?: File[];
+                    error?: string;
+                } & {
+                    multiple?: boolean;
+                    accept?: import("./types").ExtensionList | string;
+                    loader?: import("../ScalarLoading").LoadingState;
+                    variant?: "compact" | "default";
+                }> & Readonly<{
+                    "onUpdate:modelValue"?: ((value: File[]) => any) | undefined;
+                    onSelected?: ((value: File[]) => any) | undefined;
+                    "onUpdate:error"?: ((value: string) => any) | undefined;
+                }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                    "update:modelValue": (value: File[]) => any;
+                    "update:error": (value: string) => any;
+                } & {
+                    selected: (value: File[]) => any;
+                }, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<{
+                    modelValue?: File[];
+                    error?: string;
+                } & {
+                    multiple?: boolean;
+                    accept?: import("./types").ExtensionList | string;
+                    loader?: import("../ScalarLoading").LoadingState;
+                    variant?: "compact" | "default";
+                }> & Readonly<{
+                    "onUpdate:modelValue"?: ((value: File[]) => any) | undefined;
+                    onSelected?: ((value: File[]) => any) | undefined;
+                    "onUpdate:error"?: ((value: string) => any) | undefined;
+                }>, {}, {}, {}, {}, {}>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import("vue").ComponentOptionsBase<Readonly<{
+                modelValue?: File[];
+                error?: string;
+            } & {
+                multiple?: boolean;
+                accept?: import("./types").ExtensionList | string;
+                loader?: import("../ScalarLoading").LoadingState;
+                variant?: "compact" | "default";
+            }> & Readonly<{
+                "onUpdate:modelValue"?: ((value: File[]) => any) | undefined;
+                onSelected?: ((value: File[]) => any) | undefined;
+                "onUpdate:error"?: ((value: string) => any) | undefined;
+            }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                "update:modelValue": (value: File[]) => any;
+                "update:error": (value: string) => any;
+            } & {
+                selected: (value: File[]) => any;
+            }, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+                $slots: Readonly<{
+                    default?: (props: {
+                        open: () => void;
+                    }) => any;
+                    label?: () => any;
+                    'drop-target'?: () => any;
+                    'drop-target-label'?: () => any;
+                }> & {
+                    default?: (props: {
+                        open: () => void;
+                    }) => any;
+                    label?: () => any;
+                    'drop-target'?: () => any;
+                    'drop-target-label'?: () => any;
+                };
+            })>;
+            files: import("vue").Ref<{
+                readonly lastModified: number;
+                readonly name: string;
+                readonly webkitRelativePath: string;
+                readonly size: number;
+                readonly type: string;
+                arrayBuffer: () => Promise<ArrayBuffer>;
+                slice: (start?: number, end?: number, contentType?: string) => Blob;
+                stream: () => ReadableStream<Uint8Array>;
+                text: () => Promise<string>;
+            }[], File[] | {
+                readonly lastModified: number;
+                readonly name: string;
+                readonly webkitRelativePath: string;
+                readonly size: number;
+                readonly type: string;
+                arrayBuffer: () => Promise<ArrayBuffer>;
+                slice: (start?: number, end?: number, contentType?: string) => Blob;
+                stream: () => ReadableStream<Uint8Array>;
+                text: () => Promise<string>;
+            }[]>;
+        };
+        template: string;
+    };
+};
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const Base: Story;
+export declare const Compact: Story;
+export declare const Files: Story;
+export declare const Loading: Story;
+export declare const Labelled: Story;
+//# sourceMappingURL=ScalarFileUpload.stories.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ScalarFileUpload.stories.d.ts","sourceRoot":"","sources":["../../../src/components/ScalarFileUpload/ScalarFileUpload.stories.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAQ,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAOrD,QAAA,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqC+B,CAAA;AAEzC,eAAe,IAAI,CAAA;AACnB,KAAK,KAAK,GAAG,QAAQ,CAAC,OAAO,IAAI,CAAC,CAAA;AAElC,eAAO,MAAM,IAAI,EAAE,KAAU,CAAA;AAE7B,eAAO,MAAM,OAAO,EAAE,KAErB,CAAA;AAED,eAAO,MAAM,KAAK,EAAE,KAsBnB,CAAA;AACD,eAAO,MAAM,OAAO,EAAE,KAiBrB,CAAA;AAED,eAAO,MAAM,QAAQ,EAAE,KAqBtB,CAAA"}

package/dist/components/ScalarFileUpload/ScalarFileUpload.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ScalarFileUpload.test.d.ts.map

package/dist/components/ScalarFileUpload/ScalarFileUpload.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScalarFileUpload.test.d.ts","sourceRoot":"","sources":["../../../src/components/ScalarFileUpload/ScalarFileUpload.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,86 @@
+import { type ExtensionList } from './types';
+import type { LoadingState } from '../ScalarLoading';
+/**
+ * Scalar File Upload component
+ *
+ * @example
+ * <ScalarFileUpload @selected="handleSelected" />
+ *
+ * @example
+ * <ScalarFileUpload v-slot="{ open }">
+ *   <ScalarButton @click="open">Select files</ScalarButton>
+ * </ScalarFileUpload>
+ */
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
+    modelValue?: File[];
+    error?: string;
+} & {
+    /** Whether multiple files can be uploaded */
+    multiple?: boolean;
+    /**
+     * Accepted file types
+     * @default '*'
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/accept
+     */
+    accept?: ExtensionList | string;
+    /** Whether the file upload is loading */
+    loader?: LoadingState;
+    /** Whether the file upload is compact */
+    variant?: "compact" | "default";
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: File[]) => any;
+    "update:error": (value: string) => any;
+} & {
+    selected: (value: File[]) => any;
+}, string, import("vue").PublicProps, Readonly<{
+    modelValue?: File[];
+    error?: string;
+} & {
+    /** Whether multiple files can be uploaded */
+    multiple?: boolean;
+    /**
+     * Accepted file types
+     * @default '*'
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/accept
+     */
+    accept?: ExtensionList | string;
+    /** Whether the file upload is loading */
+    loader?: LoadingState;
+    /** Whether the file upload is compact */
+    variant?: "compact" | "default";
+}> & Readonly<{
+    "onUpdate:modelValue"?: ((value: File[]) => any) | undefined;
+    onSelected?: ((value: File[]) => any) | undefined;
+    "onUpdate:error"?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, Readonly<{
+    /** Override the entire input */
+    default?: (props: {
+        /** Open the file dialog to select files */
+        open: () => void;
+    }) => any;
+    /** Override the label */
+    label?: () => any;
+    /** Override the entire drop target */
+    'drop-target'?: () => any;
+    /** Override the drop target label */
+    'drop-target-label'?: () => any;
+}> & {
+    /** Override the entire input */
+    default?: (props: {
+        /** Open the file dialog to select files */
+        open: () => void;
+    }) => any;
+    /** Override the label */
+    label?: () => any;
+    /** Override the entire drop target */
+    'drop-target'?: () => any;
+    /** Override the drop target label */
+    'drop-target-label'?: () => any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=ScalarFileUpload.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ScalarFileUpload.vue.d.ts","sourceRoot":"","sources":["../../../src/components/ScalarFileUpload/ScalarFileUpload.vue"],"names":[],"mappings":"AAmLA,OAAO,EAAE,KAAK,aAAa,EAAmB,MAAM,SAAS,CAAA;AAO7D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAIpD;;;;;;;;;;GAUG;;iBAwGU,IAAI,EAAE;YACT,MAAM;;IArGd,6CAA6C;eAClC,OAAO;IAClB;;;;OAIG;aACM,aAAa,GAAG,MAAM;IAC/B,yCAAyC;aAChC,YAAY;IACrB,yCAAyC;cAC/B,SAAS,GAAG,SAAS;;;;;;;iBAyFpB,IAAI,EAAE;YACT,MAAM;;IArGd,6CAA6C;eAClC,OAAO;IAClB;;;;OAIG;aACM,aAAa,GAAG,MAAM;IAC/B,yCAAyC;aAChC,YAAY;IACrB,yCAAyC;cAC/B,SAAS,GAAG,SAAS;;;;;;IAgB/B,gCAAgC;cACpB,CAAC,KAAK,EAAE;QAClB,2CAA2C;QAC3C,IAAI,EAAE,MAAM,IAAI,CAAA;KACjB,KAAK,GAAG;IACT,yBAAyB;YACf,MAAM,GAAG;IACnB,sCAAsC;oBACtB,MAAM,GAAG;IACzB,qCAAqC;0BACf,MAAM,GAAG;;IAV/B,gCAAgC;cACpB,CAAC,KAAK,EAAE;QAClB,2CAA2C;QAC3C,IAAI,EAAE,MAAM,IAAI,CAAA;KACjB,KAAK,GAAG;IACT,yBAAyB;YACf,MAAM,GAAG;IACnB,sCAAsC;oBACtB,MAAM,GAAG;IACzB,qCAAqC;0BACf,MAAM,GAAG;;AAxCjC,wBA8QC;AAWD,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/components/ScalarFileUpload/ScalarFileUploadDropTarget.vue.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Scalar File Upload Drop Target
+ *
+ * Displays a drop target for file uploads (used when
+ * the user is dragging files over the component)
+ *
+ * @example
+ * <ScalarFileUploadDropTarget />
+ */
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=ScalarFileUploadDropTarget.vue.d.ts.map