@scalar/components 0.12.9 → 0.12.10

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

@@ -0,0 +1,389 @@
+import type { StoryObj } from '@storybook/vue3';
+declare const meta: {
+    component: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
+            loading: {
+                type: import("vue").PropType<{
+                    isValid: boolean;
+                    isInvalid: boolean;
+                    isLoading: boolean;
+                    startLoading: () => void;
+                    stopLoading: () => void;
+                    validate: (time?: number) => Promise<unknown>;
+                    invalidate: (time?: number) => Promise<unknown>;
+                    clear: (time?: number) => Promise<unknown>;
+                }>;
+            };
+            modelValue: {
+                type: import("vue").PropType<string>;
+            };
+        }>> & {
+            "onUpdate:modelValue"?: ((v: string) => any) | undefined;
+        }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            "update:modelValue": (v: string) => void;
+        }, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
+            loading: {
+                type: import("vue").PropType<{
+                    isValid: boolean;
+                    isInvalid: boolean;
+                    isLoading: boolean;
+                    startLoading: () => void;
+                    stopLoading: () => void;
+                    validate: (time?: number) => Promise<unknown>;
+                    invalidate: (time?: number) => Promise<unknown>;
+                    clear: (time?: number) => Promise<unknown>;
+                }>;
+            };
+            modelValue: {
+                type: import("vue").PropType<string>;
+            };
+        }>> & {
+            "onUpdate:modelValue"?: ((v: string) => any) | undefined;
+        }, {}, true, {}, {}, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("vue").ExtractPropTypes<{
+            loading: {
+                type: import("vue").PropType<{
+                    isValid: boolean;
+                    isInvalid: boolean;
+                    isLoading: boolean;
+                    startLoading: () => void;
+                    stopLoading: () => void;
+                    validate: (time?: number) => Promise<unknown>;
+                    invalidate: (time?: number) => Promise<unknown>;
+                    clear: (time?: number) => Promise<unknown>;
+                }>;
+            };
+            modelValue: {
+                type: import("vue").PropType<string>;
+            };
+        }>> & {
+            "onUpdate:modelValue"?: ((v: string) => any) | undefined;
+        }, {}, {}, {}, {}, {}>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+        loading: {
+            type: import("vue").PropType<{
+                isValid: boolean;
+                isInvalid: boolean;
+                isLoading: boolean;
+                startLoading: () => void;
+                stopLoading: () => void;
+                validate: (time?: number) => Promise<unknown>;
+                invalidate: (time?: number) => Promise<unknown>;
+                clear: (time?: number) => Promise<unknown>;
+            }>;
+        };
+        modelValue: {
+            type: import("vue").PropType<string>;
+        };
+    }>> & {
+        "onUpdate:modelValue"?: ((v: string) => any) | undefined;
+    }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        "update:modelValue": (v: string) => void;
+    }, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: {
+            label?(_: {}): any;
+        };
+    });
+    tags: string[];
+    argTypes: {};
+    render: (args: import("@storybook/vue3").ComponentPropsAndSlots<{
+        new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
+            loading: {
+                type: import("vue").PropType<{
+                    isValid: boolean;
+                    isInvalid: boolean;
+                    isLoading: boolean;
+                    startLoading: () => void;
+                    stopLoading: () => void;
+                    validate: (time?: number) => Promise<unknown>;
+                    invalidate: (time?: number) => Promise<unknown>;
+                    clear: (time?: number) => Promise<unknown>;
+                }>;
+            };
+            modelValue: {
+                type: import("vue").PropType<string>;
+            };
+        }>> & {
+            "onUpdate:modelValue"?: ((v: string) => any) | undefined;
+        }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            "update:modelValue": (v: string) => void;
+        }, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
+            loading: {
+                type: import("vue").PropType<{
+                    isValid: boolean;
+                    isInvalid: boolean;
+                    isLoading: boolean;
+                    startLoading: () => void;
+                    stopLoading: () => void;
+                    validate: (time?: number) => Promise<unknown>;
+                    invalidate: (time?: number) => Promise<unknown>;
+                    clear: (time?: number) => Promise<unknown>;
+                }>;
+            };
+            modelValue: {
+                type: import("vue").PropType<string>;
+            };
+        }>> & {
+            "onUpdate:modelValue"?: ((v: string) => any) | undefined;
+        }, {}, true, {}, {}, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("vue").ExtractPropTypes<{
+            loading: {
+                type: import("vue").PropType<{
+                    isValid: boolean;
+                    isInvalid: boolean;
+                    isLoading: boolean;
+                    startLoading: () => void;
+                    stopLoading: () => void;
+                    validate: (time?: number) => Promise<unknown>;
+                    invalidate: (time?: number) => Promise<unknown>;
+                    clear: (time?: number) => Promise<unknown>;
+                }>;
+            };
+            modelValue: {
+                type: import("vue").PropType<string>;
+            };
+        }>> & {
+            "onUpdate:modelValue"?: ((v: string) => any) | undefined;
+        }, {}, {}, {}, {}, {}>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+        loading: {
+            type: import("vue").PropType<{
+                isValid: boolean;
+                isInvalid: boolean;
+                isLoading: boolean;
+                startLoading: () => void;
+                stopLoading: () => void;
+                validate: (time?: number) => Promise<unknown>;
+                invalidate: (time?: number) => Promise<unknown>;
+                clear: (time?: number) => Promise<unknown>;
+            }>;
+        };
+        modelValue: {
+            type: import("vue").PropType<string>;
+        };
+    }>> & {
+        "onUpdate:modelValue"?: ((v: string) => any) | undefined;
+    }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        "update:modelValue": (v: string) => void;
+    }, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: {
+            label?(_: {}): any;
+        };
+    })>) => {
+        components: {
+            ScalarSearchInput: {
+                new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
+                    loading: {
+                        type: import("vue").PropType<{
+                            isValid: boolean;
+                            isInvalid: boolean;
+                            isLoading: boolean;
+                            startLoading: () => void;
+                            stopLoading: () => void;
+                            validate: (time?: number) => Promise<unknown>;
+                            invalidate: (time?: number) => Promise<unknown>;
+                            clear: (time?: number) => Promise<unknown>;
+                        }>;
+                    };
+                    modelValue: {
+                        type: import("vue").PropType<string>;
+                    };
+                }>> & {
+                    "onUpdate:modelValue"?: ((v: string) => any) | undefined;
+                }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                    "update:modelValue": (v: string) => void;
+                }, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
+                    loading: {
+                        type: import("vue").PropType<{
+                            isValid: boolean;
+                            isInvalid: boolean;
+                            isLoading: boolean;
+                            startLoading: () => void;
+                            stopLoading: () => void;
+                            validate: (time?: number) => Promise<unknown>;
+                            invalidate: (time?: number) => Promise<unknown>;
+                            clear: (time?: number) => Promise<unknown>;
+                        }>;
+                    };
+                    modelValue: {
+                        type: import("vue").PropType<string>;
+                    };
+                }>> & {
+                    "onUpdate:modelValue"?: ((v: string) => any) | undefined;
+                }, {}, true, {}, {}, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import("vue").ExtractPropTypes<{
+                    loading: {
+                        type: import("vue").PropType<{
+                            isValid: boolean;
+                            isInvalid: boolean;
+                            isLoading: boolean;
+                            startLoading: () => void;
+                            stopLoading: () => void;
+                            validate: (time?: number) => Promise<unknown>;
+                            invalidate: (time?: number) => Promise<unknown>;
+                            clear: (time?: number) => Promise<unknown>;
+                        }>;
+                    };
+                    modelValue: {
+                        type: import("vue").PropType<string>;
+                    };
+                }>> & {
+                    "onUpdate:modelValue"?: ((v: string) => any) | undefined;
+                }, {}, {}, {}, {}, {}>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+                loading: {
+                    type: import("vue").PropType<{
+                        isValid: boolean;
+                        isInvalid: boolean;
+                        isLoading: boolean;
+                        startLoading: () => void;
+                        stopLoading: () => void;
+                        validate: (time?: number) => Promise<unknown>;
+                        invalidate: (time?: number) => Promise<unknown>;
+                        clear: (time?: number) => Promise<unknown>;
+                    }>;
+                };
+                modelValue: {
+                    type: import("vue").PropType<string>;
+                };
+            }>> & {
+                "onUpdate:modelValue"?: ((v: string) => any) | undefined;
+            }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                "update:modelValue": (v: string) => void;
+            }, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+                $slots: {
+                    label?(_: {}): any;
+                };
+            });
+        };
+        setup(this: void): {
+            args: import("@storybook/vue3").ComponentPropsAndSlots<{
+                new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
+                    loading: {
+                        type: import("vue").PropType<{
+                            isValid: boolean;
+                            isInvalid: boolean;
+                            isLoading: boolean;
+                            startLoading: () => void;
+                            stopLoading: () => void;
+                            validate: (time?: number) => Promise<unknown>;
+                            invalidate: (time?: number) => Promise<unknown>;
+                            clear: (time?: number) => Promise<unknown>;
+                        }>;
+                    };
+                    modelValue: {
+                        type: import("vue").PropType<string>;
+                    };
+                }>> & {
+                    "onUpdate:modelValue"?: ((v: string) => any) | undefined;
+                }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                    "update:modelValue": (v: string) => void;
+                }, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
+                    loading: {
+                        type: import("vue").PropType<{
+                            isValid: boolean;
+                            isInvalid: boolean;
+                            isLoading: boolean;
+                            startLoading: () => void;
+                            stopLoading: () => void;
+                            validate: (time?: number) => Promise<unknown>;
+                            invalidate: (time?: number) => Promise<unknown>;
+                            clear: (time?: number) => Promise<unknown>;
+                        }>;
+                    };
+                    modelValue: {
+                        type: import("vue").PropType<string>;
+                    };
+                }>> & {
+                    "onUpdate:modelValue"?: ((v: string) => any) | undefined;
+                }, {}, true, {}, {}, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import("vue").ExtractPropTypes<{
+                    loading: {
+                        type: import("vue").PropType<{
+                            isValid: boolean;
+                            isInvalid: boolean;
+                            isLoading: boolean;
+                            startLoading: () => void;
+                            stopLoading: () => void;
+                            validate: (time?: number) => Promise<unknown>;
+                            invalidate: (time?: number) => Promise<unknown>;
+                            clear: (time?: number) => Promise<unknown>;
+                        }>;
+                    };
+                    modelValue: {
+                        type: import("vue").PropType<string>;
+                    };
+                }>> & {
+                    "onUpdate:modelValue"?: ((v: string) => any) | undefined;
+                }, {}, {}, {}, {}, {}>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+                loading: {
+                    type: import("vue").PropType<{
+                        isValid: boolean;
+                        isInvalid: boolean;
+                        isLoading: boolean;
+                        startLoading: () => void;
+                        stopLoading: () => void;
+                        validate: (time?: number) => Promise<unknown>;
+                        invalidate: (time?: number) => Promise<unknown>;
+                        clear: (time?: number) => Promise<unknown>;
+                    }>;
+                };
+                modelValue: {
+                    type: import("vue").PropType<string>;
+                };
+            }>> & {
+                "onUpdate:modelValue"?: ((v: string) => any) | undefined;
+            }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                "update:modelValue": (v: string) => void;
+            }, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+                $slots: {
+                    label?(_: {}): any;
+                };
+            })>;
+            model: import("vue").Ref<string>;
+        };
+        template: string;
+    };
+};
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const Base: Story;
+export declare const Loading: Story;
+//# sourceMappingURL=ScalarSearchInput.stories.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ScalarSearchInput.stories.d.ts","sourceRoot":"","sources":["../../../src/components/ScalarSearchInput/ScalarSearchInput.stories.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAQ,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAMrD,QAAA,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAYgC,CAAA;AAE1C,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,KAUrB,CAAA"}

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

@@ -0,0 +1,32 @@
+import { type LoadingState } from '../ScalarLoading';
+declare function __VLS_template(): {
+    label?(_: {}): any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_TypePropsToOption<{
+    loading?: LoadingState;
+    modelValue?: string;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (v: string) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<{
+    loading?: LoadingState;
+    modelValue?: string;
+}>>> & {
+    "onUpdate:modelValue"?: ((v: string) => any) | undefined;
+}, {}, {}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+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;
+    };
+};
+//# sourceMappingURL=ScalarSearchInput.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ScalarSearchInput.vue.d.ts","sourceRoot":"","sources":["../../../src/components/ScalarSearchInput/ScalarSearchInput.vue"],"names":[],"mappings":"AAoEA,OAAO,EAAE,KAAK,YAAY,EAAiB,MAAM,kBAAkB,CAAA;AA+BnE,iBAAS,cAAc;mBA6FI,GAAG;EAqB7B;AACD,QAAA,MAAM,eAAe;cA7IT,YAAY;iBACT,MAAM;;;;cADT,YAAY;iBACT,MAAM;;;UAmJnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAAvG,wBAAwG;AAOxG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACpC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC;AAEN,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"}

package/dist/components/ScalarSearchInput/index.d.ts

@@ -0,0 +1,2 @@
+export { default as ScalarSearchInput } from './ScalarSearchInput.vue.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/ScalarSearchInput/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/ScalarSearchInput/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,yBAAyB,CAAA"}

package/dist/components/ScalarSearchResults/ScalarSearchResultItem.vue.d.ts

@@ -0,0 +1,31 @@
+import { type Icon } from '../ScalarIcon';
+declare function __VLS_template(): {
+    icon?(_: {}): any;
+    default?(_: {}): any;
+    addon?(_: {}): any;
+    description?(_: {}): any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_TypePropsToOption<{
+    icon?: Icon;
+    active?: boolean;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<{
+    icon?: Icon;
+    active?: boolean;
+}>>>, {}, {}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+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;
+    };
+};
+//# sourceMappingURL=ScalarSearchResultItem.vue.d.ts.map

package/dist/components/ScalarSearchResults/ScalarSearchResultItem.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScalarSearchResultItem.vue.d.ts","sourceRoot":"","sources":["../../../src/components/ScalarSearchResults/ScalarSearchResultItem.vue"],"names":[],"mappings":"AAmEA,OAAO,EAAE,KAAK,IAAI,EAAc,MAAM,eAAe,CAAA;AAsBrD,iBAAS,cAAc;kBA+FG,GAAG;qBACA,GAAG;mBACL,GAAG;yBACG,GAAG;EAiBnC;AACD,QAAA,MAAM,eAAe;WArIZ,IAAI;aACF,OAAO;;WADT,IAAI;aACF,OAAO;aA0IhB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAAvG,wBAAwG;AAOxG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACpC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC;AAEN,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"}

package/dist/components/ScalarSearchResults/ScalarSearchResultItem.vue.js

@@ -1,50 +1,51 @@
-import { defineComponent as i, computed as d, useAttrs as m, openBlock as o, createElementBlock as r, createElementVNode as t, mergeProps as p, unref as a, renderSlot as s, createBlock as u, createCommentVNode as l } from "vue";
+import { defineComponent as i, computed as d, useAttrs as m, openBlock as o, createElementBlock as r, createElementVNode as t, mergeProps as u, unref as a, renderSlot as s, createBlock as p, createCommentVNode as l } from "vue";
 import { cx as f } from "../../cva.js";
 import _ from "../ScalarIcon/ScalarIcon.vue.js";
-const h = { class: "contents" }, v = { class: "text-c-3 group-hover:text-c-1" }, x = { class: "flex min-w-0 flex-1 flex-col gap-0.75" }, g = { class: "flex items-center gap-1" }, $ = { class: "flex-1 truncate text-sm font-medium" }, k = {
+const h = { class: "contents" }, x = { class: "flex h-fit items-center text-sm font-medium text-c-3 group-hover:text-c-1" }, v = /* @__PURE__ */ t("span", null, " ", -1), g = { class: "flex min-w-0 flex-1 flex-col gap-0.75" }, $ = { class: "flex items-center gap-1" }, k = { class: "flex-1 truncate text-sm font-medium" }, N = {
   key: 0,
   class: "text-xs text-c-2"
-}, N = { class: "truncate text-xs text-c-2" }, A = /* @__PURE__ */ i({
+}, b = { class: "truncate text-xs text-c-2" }, C = /* @__PURE__ */ i({
   inheritAttrs: !1,
   __name: "ScalarSearchResultItem",
   props: {
     icon: {},
     active: { type: Boolean }
   },
-  setup(b) {
-    const c = d(() => {
-      const { class: e, ...n } = m();
-      return { className: e || "", rest: n };
+  setup(y) {
+    const n = d(() => {
+      const { class: e, ...c } = m();
+      return { className: e || "", rest: c };
     });
-    return (e, n) => (o(), r("li", h, [
-      t("a", p(c.value.rest, {
+    return (e, c) => (o(), r("li", h, [
+      t("a", u(n.value.rest, {
         class: a(f)(
-          "group flex cursor-pointer gap-3 rounded px-3 py-1.5 no-underline hover:bg-b-2",
+          "group flex cursor-pointer gap-2.5 rounded px-3 py-1.5 no-underline hover:bg-b-2",
           {
             "bg-b-2": e.active
           },
-          c.value.className
+          n.value.className
         )
       }), [
-        t("div", v, [
+        t("div", x, [
           s(e.$slots, "icon", {}, () => [
-            e.icon ? (o(), u(a(_), {
+            e.icon ? (o(), p(a(_), {
               key: 0,
               icon: e.icon,
               size: "sm"
             }, null, 8, ["icon"])) : l("", !0)
-          ])
+          ]),
+          v
         ]),
-        t("div", x, [
-          t("div", g, [
-            t("div", $, [
+        t("div", g, [
+          t("div", $, [
+            t("div", k, [
               s(e.$slots, "default")
             ]),
-            e.$slots.addon ? (o(), r("div", k, [
+            e.$slots.addon ? (o(), r("div", N, [
               s(e.$slots, "addon")
             ])) : l("", !0)
           ]),
-          t("div", N, [
+          t("div", b, [
             s(e.$slots, "description")
           ])
         ])
@@ -53,5 +54,5 @@ const h = { class: "contents" }, v = { class: "text-c-3 group-hover:text-c-1" },
   }
 });
 export {
-  A as default
+  C as default
 };

package/dist/components/ScalarSearchResults/ScalarSearchResultList.vue.d.ts

@@ -0,0 +1,26 @@
+declare function __VLS_template(): {
+    noResults?(_: {}): any;
+    default?(_: {}): any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_TypePropsToOption<{
+    noResults?: boolean;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<{
+    noResults?: boolean;
+}>>>, {}, {}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+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;
+    };
+};
+//# sourceMappingURL=ScalarSearchResultList.vue.d.ts.map

package/dist/components/ScalarSearchResults/ScalarSearchResultList.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScalarSearchResultList.vue.d.ts","sourceRoot":"","sources":["../../../src/components/ScalarSearchResults/ScalarSearchResultList.vue"],"names":[],"mappings":"AAyDA,iBAAS,cAAc;uBAuCQ,GAAG;qBACL,GAAG;EAgB/B;AACD,QAAA,MAAM,eAAe;gBAzEP,OAAO;;gBAAP,OAAO;aA+EnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAAvG,wBAAwG;AAOxG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACpC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC;AAEN,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"}

package/dist/components/ScalarSearchResults/ScalarSearchResults.spec.d.ts

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

package/dist/components/ScalarSearchResults/ScalarSearchResults.spec.d.ts.map

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