npm - @scalar/components - Versions diffs - 0.12.53 → 0.12.55 - Mend

@scalar/components 0.12.53 → 0.12.55

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (212) hide show

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

@@ -1,115 +1,49 @@
 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, clear?: boolean) => Promise<unknown>;
-                    invalidate: (time?: number, clear?: boolean) => Promise<unknown>;
-                    clear: (time?: number) => Promise<unknown>;
-                }>;
-            };
-            modelValue: {
-                type: import("vue").PropType<string>;
-            };
-            sidebar: {
-                type: import("vue").PropType<boolean>;
-            };
-        }>> & {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
+            loading?: import("../ScalarLoading").LoadingState;
+            modelValue?: string;
+            sidebar?: boolean;
+        }> & Readonly<{
             "onUpdate:modelValue"?: ((v: string) => any) | undefined;
-        }, {
+        }>, {
             focus: () => void;
             blur: () => void;
-        }, 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, clear?: boolean) => Promise<unknown>;
-                    invalidate: (time?: number, clear?: boolean) => Promise<unknown>;
-                    clear: (time?: number) => Promise<unknown>;
-                }>;
-            };
-            modelValue: {
-                type: import("vue").PropType<string>;
-            };
-            sidebar: {
-                type: import("vue").PropType<boolean>;
-            };
-        }>> & {
-            "onUpdate:modelValue"?: ((v: string) => any) | undefined;
-        }, {}, true, {}, {}, {
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+            "update:modelValue": (v: string) => any;
+        }, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
             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, clear?: boolean) => Promise<unknown>;
-                    invalidate: (time?: number, clear?: boolean) => Promise<unknown>;
-                    clear: (time?: number) => Promise<unknown>;
-                }>;
-            };
-            modelValue: {
-                type: import("vue").PropType<string>;
-            };
-            sidebar: {
-                type: import("vue").PropType<boolean>;
-            };
-        }>> & {
+        }, Readonly<{
+            loading?: import("../ScalarLoading").LoadingState;
+            modelValue?: string;
+            sidebar?: boolean;
+        }> & Readonly<{
             "onUpdate:modelValue"?: ((v: string) => any) | undefined;
-        }, {
+        }>, {
             focus: () => void;
             blur: () => void;
         }, {}, {}, {}, {}>;
         __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, clear?: boolean) => Promise<unknown>;
-                invalidate: (time?: number, clear?: boolean) => Promise<unknown>;
-                clear: (time?: number) => Promise<unknown>;
-            }>;
-        };
-        modelValue: {
-            type: import("vue").PropType<string>;
-        };
-        sidebar: {
-            type: import("vue").PropType<boolean>;
-        };
-    }>> & {
+    } & import("vue").ComponentOptionsBase<Readonly<{
+        loading?: import("../ScalarLoading").LoadingState;
+        modelValue?: string;
+        sidebar?: boolean;
+    }> & Readonly<{
         "onUpdate:modelValue"?: ((v: string) => any) | undefined;
-    }, {
+    }>, {
         focus: () => void;
         blur: () => void;
-    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-        "update:modelValue": (v: string) => void;
-    }, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+        "update:modelValue": (v: string) => any;
+    }, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
         $slots: {
             label?(_: {}): any;
         };
@@ -117,230 +51,98 @@ declare const meta: {
     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, clear?: boolean) => Promise<unknown>;
-                    invalidate: (time?: number, clear?: boolean) => Promise<unknown>;
-                    clear: (time?: number) => Promise<unknown>;
-                }>;
-            };
-            modelValue: {
-                type: import("vue").PropType<string>;
-            };
-            sidebar: {
-                type: import("vue").PropType<boolean>;
-            };
-        }>> & {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
+            loading?: import("../ScalarLoading").LoadingState;
+            modelValue?: string;
+            sidebar?: boolean;
+        }> & Readonly<{
             "onUpdate:modelValue"?: ((v: string) => any) | undefined;
-        }, {
+        }>, {
             focus: () => void;
             blur: () => void;
-        }, 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, clear?: boolean) => Promise<unknown>;
-                    invalidate: (time?: number, clear?: boolean) => Promise<unknown>;
-                    clear: (time?: number) => Promise<unknown>;
-                }>;
-            };
-            modelValue: {
-                type: import("vue").PropType<string>;
-            };
-            sidebar: {
-                type: import("vue").PropType<boolean>;
-            };
-        }>> & {
-            "onUpdate:modelValue"?: ((v: string) => any) | undefined;
-        }, {}, true, {}, {}, {
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+            "update:modelValue": (v: string) => any;
+        }, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
             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, clear?: boolean) => Promise<unknown>;
-                    invalidate: (time?: number, clear?: boolean) => Promise<unknown>;
-                    clear: (time?: number) => Promise<unknown>;
-                }>;
-            };
-            modelValue: {
-                type: import("vue").PropType<string>;
-            };
-            sidebar: {
-                type: import("vue").PropType<boolean>;
-            };
-        }>> & {
+        }, Readonly<{
+            loading?: import("../ScalarLoading").LoadingState;
+            modelValue?: string;
+            sidebar?: boolean;
+        }> & Readonly<{
             "onUpdate:modelValue"?: ((v: string) => any) | undefined;
-        }, {
+        }>, {
             focus: () => void;
             blur: () => void;
         }, {}, {}, {}, {}>;
         __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, clear?: boolean) => Promise<unknown>;
-                invalidate: (time?: number, clear?: boolean) => Promise<unknown>;
-                clear: (time?: number) => Promise<unknown>;
-            }>;
-        };
-        modelValue: {
-            type: import("vue").PropType<string>;
-        };
-        sidebar: {
-            type: import("vue").PropType<boolean>;
-        };
-    }>> & {
+    } & import("vue").ComponentOptionsBase<Readonly<{
+        loading?: import("../ScalarLoading").LoadingState;
+        modelValue?: string;
+        sidebar?: boolean;
+    }> & Readonly<{
         "onUpdate:modelValue"?: ((v: string) => any) | undefined;
-    }, {
+    }>, {
         focus: () => void;
         blur: () => void;
-    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-        "update:modelValue": (v: string) => void;
-    }, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+        "update:modelValue": (v: string) => any;
+    }, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & 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, clear?: boolean) => Promise<unknown>;
-                            invalidate: (time?: number, clear?: boolean) => Promise<unknown>;
-                            clear: (time?: number) => Promise<unknown>;
-                        }>;
-                    };
-                    modelValue: {
-                        type: import("vue").PropType<string>;
-                    };
-                    sidebar: {
-                        type: import("vue").PropType<boolean>;
-                    };
-                }>> & {
+                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
+                    loading?: import("../ScalarLoading").LoadingState;
+                    modelValue?: string;
+                    sidebar?: boolean;
+                }> & Readonly<{
                     "onUpdate:modelValue"?: ((v: string) => any) | undefined;
-                }, {
+                }>, {
                     focus: () => void;
                     blur: () => void;
-                }, 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, clear?: boolean) => Promise<unknown>;
-                            invalidate: (time?: number, clear?: boolean) => Promise<unknown>;
-                            clear: (time?: number) => Promise<unknown>;
-                        }>;
-                    };
-                    modelValue: {
-                        type: import("vue").PropType<string>;
-                    };
-                    sidebar: {
-                        type: import("vue").PropType<boolean>;
-                    };
-                }>> & {
-                    "onUpdate:modelValue"?: ((v: string) => any) | undefined;
-                }, {}, true, {}, {}, {
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+                    "update:modelValue": (v: string) => any;
+                }, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                     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, clear?: boolean) => Promise<unknown>;
-                            invalidate: (time?: number, clear?: boolean) => Promise<unknown>;
-                            clear: (time?: number) => Promise<unknown>;
-                        }>;
-                    };
-                    modelValue: {
-                        type: import("vue").PropType<string>;
-                    };
-                    sidebar: {
-                        type: import("vue").PropType<boolean>;
-                    };
-                }>> & {
+                }, Readonly<{
+                    loading?: import("../ScalarLoading").LoadingState;
+                    modelValue?: string;
+                    sidebar?: boolean;
+                }> & Readonly<{
                     "onUpdate:modelValue"?: ((v: string) => any) | undefined;
-                }, {
+                }>, {
                     focus: () => void;
                     blur: () => void;
                 }, {}, {}, {}, {}>;
                 __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, clear?: boolean) => Promise<unknown>;
-                        invalidate: (time?: number, clear?: boolean) => Promise<unknown>;
-                        clear: (time?: number) => Promise<unknown>;
-                    }>;
-                };
-                modelValue: {
-                    type: import("vue").PropType<string>;
-                };
-                sidebar: {
-                    type: import("vue").PropType<boolean>;
-                };
-            }>> & {
+            } & import("vue").ComponentOptionsBase<Readonly<{
+                loading?: import("../ScalarLoading").LoadingState;
+                modelValue?: string;
+                sidebar?: boolean;
+            }> & Readonly<{
                 "onUpdate:modelValue"?: ((v: string) => any) | undefined;
-            }, {
+            }>, {
                 focus: () => void;
                 blur: () => void;
-            }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-                "update:modelValue": (v: string) => void;
-            }, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+                "update:modelValue": (v: string) => any;
+            }, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
                 $slots: {
                     label?(_: {}): any;
                 };
@@ -348,120 +150,54 @@ declare const meta: {
         };
         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, clear?: boolean) => Promise<unknown>;
-                            invalidate: (time?: number, clear?: boolean) => Promise<unknown>;
-                            clear: (time?: number) => Promise<unknown>;
-                        }>;
-                    };
-                    modelValue: {
-                        type: import("vue").PropType<string>;
-                    };
-                    sidebar: {
-                        type: import("vue").PropType<boolean>;
-                    };
-                }>> & {
+                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
+                    loading?: import("../ScalarLoading").LoadingState;
+                    modelValue?: string;
+                    sidebar?: boolean;
+                }> & Readonly<{
                     "onUpdate:modelValue"?: ((v: string) => any) | undefined;
-                }, {
+                }>, {
                     focus: () => void;
                     blur: () => void;
-                }, 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, clear?: boolean) => Promise<unknown>;
-                            invalidate: (time?: number, clear?: boolean) => Promise<unknown>;
-                            clear: (time?: number) => Promise<unknown>;
-                        }>;
-                    };
-                    modelValue: {
-                        type: import("vue").PropType<string>;
-                    };
-                    sidebar: {
-                        type: import("vue").PropType<boolean>;
-                    };
-                }>> & {
-                    "onUpdate:modelValue"?: ((v: string) => any) | undefined;
-                }, {}, true, {}, {}, {
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+                    "update:modelValue": (v: string) => any;
+                }, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                     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, clear?: boolean) => Promise<unknown>;
-                            invalidate: (time?: number, clear?: boolean) => Promise<unknown>;
-                            clear: (time?: number) => Promise<unknown>;
-                        }>;
-                    };
-                    modelValue: {
-                        type: import("vue").PropType<string>;
-                    };
-                    sidebar: {
-                        type: import("vue").PropType<boolean>;
-                    };
-                }>> & {
+                }, Readonly<{
+                    loading?: import("../ScalarLoading").LoadingState;
+                    modelValue?: string;
+                    sidebar?: boolean;
+                }> & Readonly<{
                     "onUpdate:modelValue"?: ((v: string) => any) | undefined;
-                }, {
+                }>, {
                     focus: () => void;
                     blur: () => void;
                 }, {}, {}, {}, {}>;
                 __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, clear?: boolean) => Promise<unknown>;
-                        invalidate: (time?: number, clear?: boolean) => Promise<unknown>;
-                        clear: (time?: number) => Promise<unknown>;
-                    }>;
-                };
-                modelValue: {
-                    type: import("vue").PropType<string>;
-                };
-                sidebar: {
-                    type: import("vue").PropType<boolean>;
-                };
-            }>> & {
+            } & import("vue").ComponentOptionsBase<Readonly<{
+                loading?: import("../ScalarLoading").LoadingState;
+                modelValue?: string;
+                sidebar?: boolean;
+            }> & Readonly<{
                 "onUpdate:modelValue"?: ((v: string) => any) | undefined;
-            }, {
+            }>, {
                 focus: () => void;
                 blur: () => void;
-            }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-                "update:modelValue": (v: string) => void;
-            }, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+                "update:modelValue": (v: string) => any;
+            }, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
                 $slots: {
                     label?(_: {}): any;
                 };
             })>;
-            model: import("vue").Ref<string>;
+            model: import("vue").Ref<string, string>;
         };
         template: string;
     };

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

	@@ -1 +1 @@
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"}
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 CHANGED Viewed

@@ -2,22 +2,22 @@ import { type LoadingState } from '../ScalarLoading';
 declare function __VLS_template(): {
     label?(_: {}): any;
 };
-declare const __VLS_component: import("vue").DefineComponent<__VLS_TypePropsToOption<{
+declare const __VLS_component: import("vue").DefineComponent<{
     loading?: LoadingState;
     modelValue?: string;
     sidebar?: boolean;
-}>, {
+}, {
     focus: () => void;
     blur: () => void;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (v: string) => void;
-}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<{
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "update:modelValue": (v: string) => any;
+}, string, import("vue").PublicProps, Readonly<{
     loading?: LoadingState;
     modelValue?: string;
     sidebar?: boolean;
-}>>> & {
+}> & Readonly<{
     "onUpdate:modelValue"?: ((v: string) => any) | undefined;
-}, {}, {}>;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {
@@ -25,13 +25,4 @@ type __VLS_WithTemplateSlots<T, S> = T & {
         $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 CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"ScalarSearchInput.vue.d.ts","sourceRoot":"","sources":["../../../src/components/ScalarSearchInput/ScalarSearchInput.vue"],"names":[],"mappings":"AA8FA,OAAO,EAAE,KAAK,YAAY,EAAiB,MAAM,kBAAkB,CAAA;~~AA8DnE~~,iBAAS,cAAc;mBAsGI,GAAG;~~EAwB7B~~;AACD,QAAA,MAAM,eAAe;~~cAxLT~~,YAAY;iBACT,MAAM;cACT,OAAO;;;;;;;cAFP,YAAY;iBACT,MAAM;cACT,OAAO;;;~~UA8LjB~~,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"}
1	+ {"version":3,"file":"ScalarSearchInput.vue.d.ts","sourceRoot":"","sources":["../../../src/components/ScalarSearchInput/ScalarSearchInput.vue"],"names":[],"mappings":"AA8FA,OAAO,EAAE,KAAK,YAAY,EAAiB,MAAM,kBAAkB,CAAA;AAgEnE,iBAAS,cAAc;mBAsGI,GAAG;EA0B7B;AACD,QAAA,MAAM,eAAe;cA5LT,YAAY;iBACT,MAAM;cACT,OAAO;;;;;;;cAFP,YAAY;iBACT,MAAM;cACT,OAAO;;;kFAoMjB,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"}