giime 0.4.11 → 0.5.0

package/dist/index.css

@@ -777,11 +777,22 @@ video {
 .gm-group:hover .group-hover\:gm-block {
   display: block;
 }
-
-.gm-range-number .el-form-item[data-v-11c39847] {
+.gm-upload-material .el-overlay-dialog {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+.gm-upload-material .el-dialog {
   margin: 0;
-}
-
+}
+.gm-upload-material .el-dialog__body {
+  max-height: calc(100vh - 100px);
+  overflow-y: auto;
+}
+.gm-upload-material .el-dialog__body video,
+.gm-upload-material .el-dialog__body img {
+  max-height: calc(100vh - 150px);
+}
 [data-v-7c80c3b6] .el-upload-dragger {
   padding: 10px;
   border: none;
@@ -798,6 +809,13 @@ video {
   align-items: center;
   justify-content: center;
 }
+.gm-flex-center[data-v-2a79bac9] {
+  align-items: center;
+}
+
+.gm-flex-justify-between[data-v-2a79bac9] {
+  justify-content: space-between;
+}
 .circular[data-v-b391445c] {
   animation: loading-rotate-b391445c 2s linear infinite;
 }
@@ -829,46 +847,14 @@ video {
     stroke-dashoffset: -120px;
   }
 }
-.gm-upload-material .el-overlay-dialog {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-}
-.gm-upload-material .el-dialog {
-  margin: 0;
-}
-.gm-upload-material .el-dialog__body {
-  max-height: calc(100vh - 100px);
-  overflow-y: auto;
-}
-.gm-upload-material .el-dialog__body video,
-.gm-upload-material .el-dialog__body img {
-  max-height: calc(100vh - 150px);
-}
-.gm-flex-center[data-v-2a79bac9] {
-  align-items: center;
-}
-
-.gm-flex-justify-between[data-v-2a79bac9] {
-  justify-content: space-between;
-}
-.gm-number-interval-single[data-v-47a13fd0] {
-  border-radius: var(--el-input-border-radius, var(--el-border-radius-base));
-  box-shadow: 0 0 0 1px var(--el-input-border-color, var(--el-border-color)) inset;
-  background-color: var(--el-input-bg-color, var(--el-fill-color-blank));
-}
-.gm-number-interval-single[data-v-47a13fd0] [data-v-47a13fd0] .el-input__wrapper {
-  box-shadow: none;
-  background: none;
-}
 
-.gm-number-interval-close[data-v-47a13fd0] {
-  display: none;
-  color: var(--el-input-icon-color, var(--el-text-color-placeholder));
-}
+.gm-range-number .el-form-item[data-v-11c39847] {
+  margin: 0;
+}
 
-.gm-number-interval-single[data-v-47a13fd0]:hover .gm-number-interval-close[data-v-47a13fd0] {
-  display: flex;
+[data-v-7b6755e2] .gmSearchForm .el-form-item {
+  margin-right: 0;
+  margin-bottom: 4px;
 }
 [data-v-668dc408] .gmTableNoBorder .el-table__body .el-table__cell {
   border-right: none;
@@ -893,10 +879,6 @@ video {
 [data-v-668dc408] .gmTableNoBorder .el-table__border-left-patch {
   height: 0;
 }
-[data-v-7b6755e2] .gmSearchForm .el-form-item {
-  margin-right: 0;
-  margin-bottom: 4px;
-}
 
 .pagination-container[data-v-19230954] {
   background: #fff;
@@ -905,3 +887,22 @@ video {
 .pagination-container.hidden[data-v-19230954] {
   display: none;
 }
+
+.gm-number-interval-single[data-v-47a13fd0] {
+  border-radius: var(--el-input-border-radius, var(--el-border-radius-base));
+  box-shadow: 0 0 0 1px var(--el-input-border-color, var(--el-border-color)) inset;
+  background-color: var(--el-input-bg-color, var(--el-fill-color-blank));
+}
+.gm-number-interval-single[data-v-47a13fd0] [data-v-47a13fd0] .el-input__wrapper {
+  box-shadow: none;
+  background: none;
+}
+
+.gm-number-interval-close[data-v-47a13fd0] {
+  display: none;
+  color: var(--el-input-icon-color, var(--el-text-color-placeholder));
+}
+
+.gm-number-interval-single[data-v-47a13fd0]:hover .gm-number-interval-close[data-v-47a13fd0] {
+  display: flex;
+}

package/es/components/index.mjs

@@ -262,6 +262,7 @@ export { selectOptionsEmits, selectOptionsProps } from './src/composite/selectOp
 export { GmSelectOptions } from './src/composite/selectOptions/index.mjs';
 export { importDialogEmits, importDialogProps } from './src/composite/importDialog/importDialog.mjs';
 export { GmImportDialog } from './src/composite/importDialog/index.mjs';
+export { messageTypes, normalizeMessageOptions } from './src/plugins/message/method.mjs';
 export { GmMessage } from './src/plugins/message/index.mjs';
 export { GmLoading } from './src/plugins/loading/index.mjs';
 export { GmMessageBox } from './src/plugins/messageBox/index.mjs';

package/es/components/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/es/components/src/base/affix/index.d.ts

@@ -1,425 +1,6 @@
 import Affix from './Affix.vue';
-export declare const GmAffix: import("../../../../utils").SFCWithInstall<{
-    new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
-        zIndex: import("element-plus/es/utils/index.js").EpPropFinalized<(new (...args: any[]) => any) | (() => ZIndexProperty) | ((new (...args: any[]) => any) | (() => ZIndexProperty))[], unknown, unknown, 100, boolean>;
-        target: import("element-plus/es/utils/index.js").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
-        offset: import("element-plus/es/utils/index.js").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
-        position: import("element-plus/es/utils/index.js").EpPropFinalized<StringConstructor, "bottom" | "top", unknown, "top", boolean>;
-    }>> & {
-        onScroll?: ((args_0: {
-            scrollTop: number;
-            fixed: boolean;
-        }) => any) | undefined;
-        onChange?: ((fixed: boolean) => any) | undefined;
-    }, {
-        elRef: import("vue").Ref<({
-            $: import("vue").ComponentInternalInstance;
-            $data: {};
-            $props: Partial<{
-                readonly position: import("element-plus/es/utils/index.js").EpPropMergeType<StringConstructor, "bottom" | "top", unknown>;
-                readonly zIndex: any;
-                readonly offset: number;
-                readonly target: string;
-            }> & Omit<{
-                readonly position: import("element-plus/es/utils/index.js").EpPropMergeType<StringConstructor, "bottom" | "top", unknown>;
-                readonly zIndex: any;
-                readonly offset: number;
-                readonly target: string;
-                onScroll?: ((args_0: {
-                    scrollTop: number;
-                    fixed: boolean;
-                }) => any) | undefined;
-                onChange?: ((fixed: boolean) => any) | undefined;
-            } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
-                readonly zIndex: import("element-plus/es/utils/index.js").EpPropFinalized<(new (...args: any[]) => any) | (() => any) | ((new (...args: any[]) => any) | (() => any))[], unknown, unknown, 100, boolean>;
-                readonly target: import("element-plus/es/utils/index.js").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
-                readonly offset: import("element-plus/es/utils/index.js").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
-                readonly position: import("element-plus/es/utils/index.js").EpPropFinalized<StringConstructor, "bottom" | "top", unknown, "top", boolean>;
-            }>> & {
-                onScroll?: ((args_0: {
-                    scrollTop: number;
-                    fixed: boolean;
-                }) => any) | undefined;
-                onChange?: ((fixed: boolean) => any) | undefined;
-            }, "position" | "zIndex" | "offset" | "target">;
-            $attrs: {
-                [x: string]: unknown;
-            };
-            $refs: {
-                [x: string]: unknown;
-            };
-            $slots: Readonly<{
-                [name: string]: import("vue").Slot<any> | undefined;
-            }>;
-            $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null;
-            $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null;
-            $emit: ((event: "scroll", args_0: {
-                scrollTop: number;
-                fixed: boolean;
-            }) => void) & ((event: "change", fixed: boolean) => void);
-            $el: any;
-            $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-                readonly zIndex: import("element-plus/es/utils/index.js").EpPropFinalized<(new (...args: any[]) => any) | (() => any) | ((new (...args: any[]) => any) | (() => any))[], unknown, unknown, 100, boolean>;
-                readonly target: import("element-plus/es/utils/index.js").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
-                readonly offset: import("element-plus/es/utils/index.js").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
-                readonly position: import("element-plus/es/utils/index.js").EpPropFinalized<StringConstructor, "bottom" | "top", unknown, "top", boolean>;
-            }>> & {
-                onScroll?: ((args_0: {
-                    scrollTop: number;
-                    fixed: boolean;
-                }) => any) | undefined;
-                onChange?: ((fixed: boolean) => any) | undefined;
-            }, {
-                update: () => void;
-                updateRoot: () => void;
-            }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-                scroll: (args_0: {
-                    scrollTop: number;
-                    fixed: boolean;
-                }) => void;
-                change: (fixed: boolean) => void;
-            }, string, {
-                readonly position: import("element-plus/es/utils/index.js").EpPropMergeType<StringConstructor, "bottom" | "top", unknown>;
-                readonly zIndex: any;
-                readonly offset: number;
-                readonly target: string;
-            }, {}, string, {}> & {
-                beforeCreate?: ((() => void) | (() => void)[]) | undefined;
-                created?: ((() => void) | (() => void)[]) | undefined;
-                beforeMount?: ((() => void) | (() => void)[]) | undefined;
-                mounted?: ((() => void) | (() => void)[]) | undefined;
-                beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
-                updated?: ((() => void) | (() => void)[]) | undefined;
-                activated?: ((() => void) | (() => void)[]) | undefined;
-                deactivated?: ((() => void) | (() => void)[]) | undefined;
-                beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
-                beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
-                destroyed?: ((() => void) | (() => void)[]) | undefined;
-                unmounted?: ((() => void) | (() => void)[]) | undefined;
-                renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
-                renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
-                errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void)[]) | undefined;
-            };
-            $forceUpdate: () => void;
-            $nextTick: typeof import("vue").nextTick;
-            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
-        } & Omit<Readonly<import("vue").ExtractPropTypes<{
-            readonly zIndex: import("element-plus/es/utils/index.js").EpPropFinalized<(new (...args: any[]) => any) | (() => any) | ((new (...args: any[]) => any) | (() => any))[], unknown, unknown, 100, boolean>;
-            readonly target: import("element-plus/es/utils/index.js").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
-            readonly offset: import("element-plus/es/utils/index.js").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
-            readonly position: import("element-plus/es/utils/index.js").EpPropFinalized<StringConstructor, "bottom" | "top", unknown, "top", boolean>;
-        }>> & {
-            onScroll?: ((args_0: {
-                scrollTop: number;
-                fixed: boolean;
-            }) => any) | undefined;
-            onChange?: ((fixed: boolean) => any) | undefined;
-        }, "update" | "updateRoot"> & import("vue").ShallowUnwrapRef<{
-            update: () => void;
-            updateRoot: () => void;
-        }> & {} & import("vue").ComponentCustomProperties & {} & {
-            $slots: {
-                default?(_: {}): any;
-            };
-        }) | undefined>;
-    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-        scroll: (args_0: {
-            scrollTop: number;
-            fixed: boolean;
-        }) => void;
-        change: (fixed: boolean) => void;
-    }, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
-        zIndex: import("element-plus/es/utils/index.js").EpPropFinalized<(new (...args: any[]) => any) | (() => ZIndexProperty) | ((new (...args: any[]) => any) | (() => ZIndexProperty))[], unknown, unknown, 100, boolean>;
-        target: import("element-plus/es/utils/index.js").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
-        offset: import("element-plus/es/utils/index.js").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
-        position: import("element-plus/es/utils/index.js").EpPropFinalized<StringConstructor, "bottom" | "top", unknown, "top", boolean>;
-    }>> & {
-        onScroll?: ((args_0: {
-            scrollTop: number;
-            fixed: boolean;
-        }) => any) | undefined;
-        onChange?: ((fixed: boolean) => any) | undefined;
-    }, {
-        position: import("element-plus/es/utils/index.js").EpPropMergeType<StringConstructor, "bottom" | "top", unknown>;
-        zIndex: any;
-        offset: number;
-        target: string;
-    }, true, {}, {}, {
-        P: {};
-        B: {};
-        D: {};
-        C: {};
-        M: {};
-        Defaults: {};
-    }, Readonly<import("vue").ExtractPropTypes<{
-        zIndex: import("element-plus/es/utils/index.js").EpPropFinalized<(new (...args: any[]) => any) | (() => ZIndexProperty) | ((new (...args: any[]) => any) | (() => ZIndexProperty))[], unknown, unknown, 100, boolean>;
-        target: import("element-plus/es/utils/index.js").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
-        offset: import("element-plus/es/utils/index.js").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
-        position: import("element-plus/es/utils/index.js").EpPropFinalized<StringConstructor, "bottom" | "top", unknown, "top", boolean>;
-    }>> & {
-        onScroll?: ((args_0: {
-            scrollTop: number;
-            fixed: boolean;
-        }) => any) | undefined;
-        onChange?: ((fixed: boolean) => any) | undefined;
-    }, {
-        elRef: import("vue").Ref<({
-            $: import("vue").ComponentInternalInstance;
-            $data: {};
-            $props: Partial<{
-                readonly position: import("element-plus/es/utils/index.js").EpPropMergeType<StringConstructor, "bottom" | "top", unknown>;
-                readonly zIndex: any;
-                readonly offset: number;
-                readonly target: string;
-            }> & Omit<{
-                readonly position: import("element-plus/es/utils/index.js").EpPropMergeType<StringConstructor, "bottom" | "top", unknown>;
-                readonly zIndex: any;
-                readonly offset: number;
-                readonly target: string;
-                onScroll?: ((args_0: {
-                    scrollTop: number;
-                    fixed: boolean;
-                }) => any) | undefined;
-                onChange?: ((fixed: boolean) => any) | undefined;
-            } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
-                readonly zIndex: import("element-plus/es/utils/index.js").EpPropFinalized<(new (...args: any[]) => any) | (() => any) | ((new (...args: any[]) => any) | (() => any))[], unknown, unknown, 100, boolean>;
-                readonly target: import("element-plus/es/utils/index.js").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
-                readonly offset: import("element-plus/es/utils/index.js").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
-                readonly position: import("element-plus/es/utils/index.js").EpPropFinalized<StringConstructor, "bottom" | "top", unknown, "top", boolean>;
-            }>> & {
-                onScroll?: ((args_0: {
-                    scrollTop: number;
-                    fixed: boolean;
-                }) => any) | undefined;
-                onChange?: ((fixed: boolean) => any) | undefined;
-            }, "position" | "zIndex" | "offset" | "target">;
-            $attrs: {
-                [x: string]: unknown;
-            };
-            $refs: {
-                [x: string]: unknown;
-            };
-            $slots: Readonly<{
-                [name: string]: import("vue").Slot<any> | undefined;
-            }>;
-            $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null;
-            $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null;
-            $emit: ((event: "scroll", args_0: {
-                scrollTop: number;
-                fixed: boolean;
-            }) => void) & ((event: "change", fixed: boolean) => void);
-            $el: any;
-            $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-                readonly zIndex: import("element-plus/es/utils/index.js").EpPropFinalized<(new (...args: any[]) => any) | (() => any) | ((new (...args: any[]) => any) | (() => any))[], unknown, unknown, 100, boolean>;
-                readonly target: import("element-plus/es/utils/index.js").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
-                readonly offset: import("element-plus/es/utils/index.js").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
-                readonly position: import("element-plus/es/utils/index.js").EpPropFinalized<StringConstructor, "bottom" | "top", unknown, "top", boolean>;
-            }>> & {
-                onScroll?: ((args_0: {
-                    scrollTop: number;
-                    fixed: boolean;
-                }) => any) | undefined;
-                onChange?: ((fixed: boolean) => any) | undefined;
-            }, {
-                update: () => void;
-                updateRoot: () => void;
-            }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-                scroll: (args_0: {
-                    scrollTop: number;
-                    fixed: boolean;
-                }) => void;
-                change: (fixed: boolean) => void;
-            }, string, {
-                readonly position: import("element-plus/es/utils/index.js").EpPropMergeType<StringConstructor, "bottom" | "top", unknown>;
-                readonly zIndex: any;
-                readonly offset: number;
-                readonly target: string;
-            }, {}, string, {}> & {
-                beforeCreate?: ((() => void) | (() => void)[]) | undefined;
-                created?: ((() => void) | (() => void)[]) | undefined;
-                beforeMount?: ((() => void) | (() => void)[]) | undefined;
-                mounted?: ((() => void) | (() => void)[]) | undefined;
-                beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
-                updated?: ((() => void) | (() => void)[]) | undefined;
-                activated?: ((() => void) | (() => void)[]) | undefined;
-                deactivated?: ((() => void) | (() => void)[]) | undefined;
-                beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
-                beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
-                destroyed?: ((() => void) | (() => void)[]) | undefined;
-                unmounted?: ((() => void) | (() => void)[]) | undefined;
-                renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
-                renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
-                errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void)[]) | undefined;
-            };
-            $forceUpdate: () => void;
-            $nextTick: typeof import("vue").nextTick;
-            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
-        } & Omit<Readonly<import("vue").ExtractPropTypes<{
-            readonly zIndex: import("element-plus/es/utils/index.js").EpPropFinalized<(new (...args: any[]) => any) | (() => any) | ((new (...args: any[]) => any) | (() => any))[], unknown, unknown, 100, boolean>;
-            readonly target: import("element-plus/es/utils/index.js").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
-            readonly offset: import("element-plus/es/utils/index.js").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
-            readonly position: import("element-plus/es/utils/index.js").EpPropFinalized<StringConstructor, "bottom" | "top", unknown, "top", boolean>;
-        }>> & {
-            onScroll?: ((args_0: {
-                scrollTop: number;
-                fixed: boolean;
-            }) => any) | undefined;
-            onChange?: ((fixed: boolean) => any) | undefined;
-        }, "update" | "updateRoot"> & import("vue").ShallowUnwrapRef<{
-            update: () => void;
-            updateRoot: () => void;
-        }> & {} & import("vue").ComponentCustomProperties & {} & {
-            $slots: {
-                default?(_: {}): any;
-            };
-        }) | undefined>;
-    }, {}, {}, {}, {
-        position: import("element-plus/es/utils/index.js").EpPropMergeType<StringConstructor, "bottom" | "top", unknown>;
-        zIndex: any;
-        offset: number;
-        target: string;
-    }>;
-    __isFragment?: undefined;
-    __isTeleport?: undefined;
-    __isSuspense?: undefined;
-} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-    zIndex: import("element-plus/es/utils/index.js").EpPropFinalized<(new (...args: any[]) => any) | (() => ZIndexProperty) | ((new (...args: any[]) => any) | (() => ZIndexProperty))[], unknown, unknown, 100, boolean>;
-    target: import("element-plus/es/utils/index.js").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
-    offset: import("element-plus/es/utils/index.js").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
-    position: import("element-plus/es/utils/index.js").EpPropFinalized<StringConstructor, "bottom" | "top", unknown, "top", boolean>;
-}>> & {
-    onScroll?: ((args_0: {
-        scrollTop: number;
-        fixed: boolean;
-    }) => any) | undefined;
-    onChange?: ((fixed: boolean) => any) | undefined;
-}, {
-    elRef: import("vue").Ref<({
-        $: import("vue").ComponentInternalInstance;
-        $data: {};
-        $props: Partial<{
-            readonly position: import("element-plus/es/utils/index.js").EpPropMergeType<StringConstructor, "bottom" | "top", unknown>;
-            readonly zIndex: any;
-            readonly offset: number;
-            readonly target: string;
-        }> & Omit<{
-            readonly position: import("element-plus/es/utils/index.js").EpPropMergeType<StringConstructor, "bottom" | "top", unknown>;
-            readonly zIndex: any;
-            readonly offset: number;
-            readonly target: string;
-            onScroll?: ((args_0: {
-                scrollTop: number;
-                fixed: boolean;
-            }) => any) | undefined;
-            onChange?: ((fixed: boolean) => any) | undefined;
-        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
-            readonly zIndex: import("element-plus/es/utils/index.js").EpPropFinalized<(new (...args: any[]) => any) | (() => any) | ((new (...args: any[]) => any) | (() => any))[], unknown, unknown, 100, boolean>;
-            readonly target: import("element-plus/es/utils/index.js").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
-            readonly offset: import("element-plus/es/utils/index.js").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
-            readonly position: import("element-plus/es/utils/index.js").EpPropFinalized<StringConstructor, "bottom" | "top", unknown, "top", boolean>;
-        }>> & {
-            onScroll?: ((args_0: {
-                scrollTop: number;
-                fixed: boolean;
-            }) => any) | undefined;
-            onChange?: ((fixed: boolean) => any) | undefined;
-        }, "position" | "zIndex" | "offset" | "target">;
-        $attrs: {
-            [x: string]: unknown;
-        };
-        $refs: {
-            [x: string]: unknown;
-        };
-        $slots: Readonly<{
-            [name: string]: import("vue").Slot<any> | undefined;
-        }>;
-        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null;
-        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null;
-        $emit: ((event: "scroll", args_0: {
-            scrollTop: number;
-            fixed: boolean;
-        }) => void) & ((event: "change", fixed: boolean) => void);
-        $el: any;
-        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-            readonly zIndex: import("element-plus/es/utils/index.js").EpPropFinalized<(new (...args: any[]) => any) | (() => any) | ((new (...args: any[]) => any) | (() => any))[], unknown, unknown, 100, boolean>;
-            readonly target: import("element-plus/es/utils/index.js").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
-            readonly offset: import("element-plus/es/utils/index.js").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
-            readonly position: import("element-plus/es/utils/index.js").EpPropFinalized<StringConstructor, "bottom" | "top", unknown, "top", boolean>;
-        }>> & {
-            onScroll?: ((args_0: {
-                scrollTop: number;
-                fixed: boolean;
-            }) => any) | undefined;
-            onChange?: ((fixed: boolean) => any) | undefined;
-        }, {
-            update: () => void;
-            updateRoot: () => void;
-        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-            scroll: (args_0: {
-                scrollTop: number;
-                fixed: boolean;
-            }) => void;
-            change: (fixed: boolean) => void;
-        }, string, {
-            readonly position: import("element-plus/es/utils/index.js").EpPropMergeType<StringConstructor, "bottom" | "top", unknown>;
-            readonly zIndex: any;
-            readonly offset: number;
-            readonly target: string;
-        }, {}, string, {}> & {
-            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
-            created?: ((() => void) | (() => void)[]) | undefined;
-            beforeMount?: ((() => void) | (() => void)[]) | undefined;
-            mounted?: ((() => void) | (() => void)[]) | undefined;
-            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
-            updated?: ((() => void) | (() => void)[]) | undefined;
-            activated?: ((() => void) | (() => void)[]) | undefined;
-            deactivated?: ((() => void) | (() => void)[]) | undefined;
-            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
-            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
-            destroyed?: ((() => void) | (() => void)[]) | undefined;
-            unmounted?: ((() => void) | (() => void)[]) | undefined;
-            renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
-            renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
-            errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void)[]) | undefined;
-        };
-        $forceUpdate: () => void;
-        $nextTick: typeof import("vue").nextTick;
-        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
-    } & Omit<Readonly<import("vue").ExtractPropTypes<{
-        readonly zIndex: import("element-plus/es/utils/index.js").EpPropFinalized<(new (...args: any[]) => any) | (() => any) | ((new (...args: any[]) => any) | (() => any))[], unknown, unknown, 100, boolean>;
-        readonly target: import("element-plus/es/utils/index.js").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
-        readonly offset: import("element-plus/es/utils/index.js").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
-        readonly position: import("element-plus/es/utils/index.js").EpPropFinalized<StringConstructor, "bottom" | "top", unknown, "top", boolean>;
-    }>> & {
-        onScroll?: ((args_0: {
-            scrollTop: number;
-            fixed: boolean;
-        }) => any) | undefined;
-        onChange?: ((fixed: boolean) => any) | undefined;
-    }, "update" | "updateRoot"> & import("vue").ShallowUnwrapRef<{
-        update: () => void;
-        updateRoot: () => void;
-    }> & {} & import("vue").ComponentCustomProperties & {} & {
-        $slots: {
-            default?(_: {}): any;
-        };
-    }) | undefined>;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    scroll: (args_0: {
-        scrollTop: number;
-        fixed: boolean;
-    }) => void;
-    change: (fixed: boolean) => void;
-}, string, {
-    position: import("element-plus/es/utils/index.js").EpPropMergeType<StringConstructor, "bottom" | "top", unknown>;
-    zIndex: any;
-    offset: number;
-    target: string;
-}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
-    $slots: {
-        default?(_: {}): any;
-    };
-})> & Record<string, any>;
+import type { SFCWithInstall } from 'element-plus/es/utils/vue/typescript';
+export declare const GmAffix: SFCWithInstall<typeof Affix>;
 export type AffixInstance = InstanceType<typeof Affix>;
 export * from './affix';
 export default GmAffix;

package/es/components/src/base/affix/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":["../../../../../../../packages/components/src/base/affix/index.ts"],"sourcesContent":["import { withInstall } from '@giime/utils';\r\nimport Affix from './Affix.vue';\r\n\r\nexport const GmAffix = withInstall(Affix);\r\nexport type AffixInstance = InstanceType<typeof Affix>;\r\nexport * from './affix';\r\nexport default GmAffix;\r\n"],"names":["Affix"],"mappings":";;;;;;AAGa,MAAA,OAAA,GAAU,YAAYA,SAAK;;;;"}
+{"version":3,"file":"index.mjs","sources":["../../../../../../../packages/components/src/base/affix/index.ts"],"sourcesContent":["import { withInstall } from '@giime/utils';\nimport Affix from './Affix.vue';\nimport type { SFCWithInstall } from 'element-plus/es/utils/vue/typescript';\n\nexport const GmAffix: SFCWithInstall<typeof Affix> = withInstall(Affix);\nexport type AffixInstance = InstanceType<typeof Affix>;\nexport * from './affix';\nexport default GmAffix;\n"],"names":["Affix"],"mappings":";;;;;;AAIa,MAAA,OAAA,GAAwC,YAAYA,SAAK;;;;"}

package/es/components/src/base/input/Input.vue.d.ts

@@ -85,11 +85,11 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
 }, {
     textarea: HTMLTextAreaElement | undefined;
     clear: () => void;
+    ref: HTMLInputElement | HTMLTextAreaElement | undefined;
     input: HTMLInputElement | undefined;
     focus: () => Promise<void>;
     blur: () => void | undefined;
     select: () => void;
-    ref: HTMLInputElement | HTMLTextAreaElement | undefined;
     textareaStyle: import("vue").StyleValue;
     resizeTextarea: () => void;
 }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {

package/es/components/src/base/input/index.d.ts

@@ -100,11 +100,11 @@ export declare const GmInput: import("../../../../utils").SFCWithInstall<{
     }, {
         textarea: HTMLTextAreaElement | undefined;
         clear: () => void;
+        ref: HTMLInputElement | HTMLTextAreaElement | undefined;
         input: HTMLInputElement | undefined;
         focus: () => Promise<void>;
         blur: () => void | undefined;
         select: () => void;
-        ref: HTMLInputElement | HTMLTextAreaElement | undefined;
         textareaStyle: import("vue").StyleValue;
         resizeTextarea: () => void;
     }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
@@ -341,11 +341,11 @@ export declare const GmInput: import("../../../../utils").SFCWithInstall<{
     }, {
         textarea: HTMLTextAreaElement | undefined;
         clear: () => void;
+        ref: HTMLInputElement | HTMLTextAreaElement | undefined;
         input: HTMLInputElement | undefined;
         focus: () => Promise<void>;
         blur: () => void | undefined;
         select: () => void;
-        ref: HTMLInputElement | HTMLTextAreaElement | undefined;
         textareaStyle: import("vue").StyleValue;
         resizeTextarea: () => void;
     }, {}, {}, {}, {
@@ -469,11 +469,11 @@ export declare const GmInput: import("../../../../utils").SFCWithInstall<{
 }, {
     textarea: HTMLTextAreaElement | undefined;
     clear: () => void;
+    ref: HTMLInputElement | HTMLTextAreaElement | undefined;
     input: HTMLInputElement | undefined;
     focus: () => Promise<void>;
     blur: () => void | undefined;
     select: () => void;
-    ref: HTMLInputElement | HTMLTextAreaElement | undefined;
     textareaStyle: import("vue").StyleValue;
     resizeTextarea: () => void;
 }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {