delta-comic-core 0.0.1

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

@@ -0,0 +1,26 @@
+declare const _default: <T extends PromiseLike<unknown>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, never> & {
+        promise: () => T;
+        autoLoad?: boolean;
+    } & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: Readonly<{
+        default(arg: {
+            result: Awaited<T> | undefined;
+            load: () => Promise<T>;
+        }): any;
+    }> & {
+        default(arg: {
+            result: Awaited<T> | undefined;
+            load: () => Promise<T>;
+        }): any;
+    };
+    emit: {};
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/content/unitCard.vue.d.ts

@@ -0,0 +1,317 @@
+import { uni } from '../../struct';
+import { StyleValue } from 'vue';
+type __VLS_Props = {
+    item: uni.item.Item | uni.item.RawItem;
+    freeHeight?: boolean;
+    disabled?: boolean;
+    type?: 'default' | 'big' | 'small';
+    class?: any;
+    style?: StyleValue;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default(): void;
+        smallTopInfo(): void;
+    }> & {
+        default(): void;
+        smallTopInfo(): void;
+    };
+    refs: {
+        container: HTMLDivElement;
+        cover: {
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                fetchpriority: "high" | "low" | "auto";
+                retryMax: number;
+            }> & Omit<{
+                readonly src?: uni.image.Image_;
+                readonly alt?: string;
+                readonly previewable?: boolean;
+                readonly retryMax?: number;
+                readonly round?: boolean;
+                readonly fit?: import('naive-ui').ImageProps["objectFit"];
+                readonly class?: any;
+                readonly hideLoading?: boolean;
+                readonly hideError?: boolean;
+                readonly inline?: boolean;
+                readonly style?: StyleValue;
+                readonly imgProp?: import('vue').ImgHTMLAttributes;
+                readonly useList?: {
+                    loaded: Set<string>;
+                    error: Set<string>;
+                };
+                readonly fetchpriority?: "high" | "low" | "auto";
+                readonly fallback?: uni.image.Image_;
+                readonly onLoad?: (...args: any[]) => any;
+                readonly onClick?: () => any;
+                readonly onError?: () => any;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "fetchpriority" | "retryMax">;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            } & {
+                img: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any>;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "load", ...args: any[]) => void) & ((event: "click") => void) & ((event: "error") => void);
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<{
+                src?: uni.image.Image_;
+                alt?: string;
+                previewable?: boolean;
+                retryMax?: number;
+                round?: boolean;
+                fit?: import('naive-ui').ImageProps["objectFit"];
+                class?: any;
+                hideLoading?: boolean;
+                hideError?: boolean;
+                inline?: boolean;
+                style?: StyleValue;
+                imgProp?: import('vue').ImgHTMLAttributes;
+                useList?: {
+                    loaded: Set<string>;
+                    error: Set<string>;
+                };
+                fetchpriority?: "high" | "low" | "auto";
+                fallback?: uni.image.Image_;
+            }> & Readonly<{
+                onLoad?: (...args: any[]) => any;
+                onClick?: () => any;
+                onError?: () => any;
+            }>, {
+                isLoaded: import('vue').ComputedRef<boolean>;
+                imageEl: any;
+                imageIns: unknown;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                load: (...args: any[]) => any;
+                click: () => any;
+                error: () => any;
+            }, string, {
+                fetchpriority: "high" | "low" | "auto";
+                retryMax: number;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import('vue').nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+        } & Readonly<{
+            fetchpriority: "high" | "low" | "auto";
+            retryMax: number;
+        }> & Omit<Readonly<{
+            src?: uni.image.Image_;
+            alt?: string;
+            previewable?: boolean;
+            retryMax?: number;
+            round?: boolean;
+            fit?: import('naive-ui').ImageProps["objectFit"];
+            class?: any;
+            hideLoading?: boolean;
+            hideError?: boolean;
+            inline?: boolean;
+            style?: StyleValue;
+            imgProp?: import('vue').ImgHTMLAttributes;
+            useList?: {
+                loaded: Set<string>;
+                error: Set<string>;
+            };
+            fetchpriority?: "high" | "low" | "auto";
+            fallback?: uni.image.Image_;
+        }> & Readonly<{
+            onLoad?: (...args: any[]) => any;
+            onClick?: () => any;
+            onError?: () => any;
+        }>, ("fetchpriority" | "retryMax") | "isLoaded" | "imageEl" | "imageIns"> & import('vue').ShallowUnwrapRef<{
+            isLoaded: import('vue').ComputedRef<boolean>;
+            imageEl: any;
+            imageIns: unknown;
+        }> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: Readonly<{
+                loading?(): any;
+                fail?(): any;
+            }> & {
+                loading?(): any;
+                fail?(): any;
+            };
+        };
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClick?: () => any;
+}>, {
+    type: "default" | "big" | "small";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    container: HTMLDivElement;
+    cover: {
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            fetchpriority: "high" | "low" | "auto";
+            retryMax: number;
+        }> & Omit<{
+            readonly src?: uni.image.Image_;
+            readonly alt?: string;
+            readonly previewable?: boolean;
+            readonly retryMax?: number;
+            readonly round?: boolean;
+            readonly fit?: import('naive-ui').ImageProps["objectFit"];
+            readonly class?: any;
+            readonly hideLoading?: boolean;
+            readonly hideError?: boolean;
+            readonly inline?: boolean;
+            readonly style?: StyleValue;
+            readonly imgProp?: import('vue').ImgHTMLAttributes;
+            readonly useList?: {
+                loaded: Set<string>;
+                error: Set<string>;
+            };
+            readonly fetchpriority?: "high" | "low" | "auto";
+            readonly fallback?: uni.image.Image_;
+            readonly onLoad?: (...args: any[]) => any;
+            readonly onClick?: () => any;
+            readonly onError?: () => any;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "fetchpriority" | "retryMax">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            img: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any>;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "load", ...args: any[]) => void) & ((event: "click") => void) & ((event: "error") => void);
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<{
+            src?: uni.image.Image_;
+            alt?: string;
+            previewable?: boolean;
+            retryMax?: number;
+            round?: boolean;
+            fit?: import('naive-ui').ImageProps["objectFit"];
+            class?: any;
+            hideLoading?: boolean;
+            hideError?: boolean;
+            inline?: boolean;
+            style?: StyleValue;
+            imgProp?: import('vue').ImgHTMLAttributes;
+            useList?: {
+                loaded: Set<string>;
+                error: Set<string>;
+            };
+            fetchpriority?: "high" | "low" | "auto";
+            fallback?: uni.image.Image_;
+        }> & Readonly<{
+            onLoad?: (...args: any[]) => any;
+            onClick?: () => any;
+            onError?: () => any;
+        }>, {
+            isLoaded: import('vue').ComputedRef<boolean>;
+            imageEl: any;
+            imageIns: unknown;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            load: (...args: any[]) => any;
+            click: () => any;
+            error: () => any;
+        }, string, {
+            fetchpriority: "high" | "low" | "auto";
+            retryMax: number;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import('vue').nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
+        fetchpriority: "high" | "low" | "auto";
+        retryMax: number;
+    }> & Omit<Readonly<{
+        src?: uni.image.Image_;
+        alt?: string;
+        previewable?: boolean;
+        retryMax?: number;
+        round?: boolean;
+        fit?: import('naive-ui').ImageProps["objectFit"];
+        class?: any;
+        hideLoading?: boolean;
+        hideError?: boolean;
+        inline?: boolean;
+        style?: StyleValue;
+        imgProp?: import('vue').ImgHTMLAttributes;
+        useList?: {
+            loaded: Set<string>;
+            error: Set<string>;
+        };
+        fetchpriority?: "high" | "low" | "auto";
+        fallback?: uni.image.Image_;
+    }> & Readonly<{
+        onLoad?: (...args: any[]) => any;
+        onClick?: () => any;
+        onError?: () => any;
+    }>, ("fetchpriority" | "retryMax") | "isLoaded" | "imageEl" | "imageIns"> & import('vue').ShallowUnwrapRef<{
+        isLoaded: import('vue').ComputedRef<boolean>;
+        imageEl: any;
+        imageIns: unknown;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: Readonly<{
+            loading?(): any;
+            fail?(): any;
+        }> & {
+            loading?(): any;
+            fail?(): any;
+        };
+    };
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,43 @@
+import { PromiseContent, Stream } from '../utils/data';
+import { StyleValue } from 'vue';
+declare const _default: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onRetry?: () => any;
+        readonly onResetRetry?: () => any;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onRetry" | "onResetRetry"> & ({
+        retriable?: boolean;
+        hideError?: boolean;
+        hideEmpty?: boolean;
+        hideLoading?: boolean;
+        source: PromiseContent<any, T[]> | Stream<T> | T[] | T;
+    } & {
+        class?: any;
+        classError?: any;
+        classEmpty?: any;
+        classLoading?: any;
+        style?: StyleValue;
+        styleError?: StyleValue;
+        styleEmpty?: StyleValue;
+        styleLoading?: StyleValue;
+    }) & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        cont: Readonly<import('vue').ShallowRef<HTMLDivElement>>;
+    }>): void;
+    attrs: any;
+    slots: Readonly<{
+        default(data: {
+            data?: T;
+        }): any;
+    }> & {
+        default(data: {
+            data?: T;
+        }): any;
+    };
+    emit: ((evt: "retry") => void) & ((evt: "resetRetry") => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

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

@@ -0,0 +1,39 @@
+import { StyleValue } from 'vue';
+type __VLS_Props = {
+    anchors?: 'high' | 'low' | number[];
+    lockScroll?: boolean;
+    class?: any;
+    style?: StyleValue;
+    overlay?: boolean;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default(arg: {
+            height: number;
+        }): void;
+    }> & {
+        default(arg: {
+            height: number;
+        }): void;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {
+    show(node?: number): void;
+    close(): void;
+    isShowing: Readonly<import('vue').ShallowRef<boolean, boolean>>;
+    height: Readonly<import('vue').ShallowRef<number, number>>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    anchors: "high" | "low" | number[];
+    lockScroll: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,63 @@
+import { ImgHTMLAttributes, StyleValue } from 'vue';
+import { ImageProps } from 'naive-ui';
+import { uni } from '../struct';
+type __VLS_Props = {
+    src?: uni.image.Image_;
+    alt?: string;
+    previewable?: boolean;
+    retryMax?: number;
+    round?: boolean;
+    fit?: ImageProps['objectFit'];
+    class?: any;
+    hideLoading?: boolean;
+    hideError?: boolean;
+    inline?: boolean;
+    style?: StyleValue;
+    imgProp?: ImgHTMLAttributes;
+    useList?: {
+        loaded: Set<string>;
+        error: Set<string>;
+    };
+    fetchpriority?: 'high' | 'low' | 'auto';
+    fallback?: uni.image.Image_;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        loading?(): any;
+        fail?(): any;
+    }> & {
+        loading?(): any;
+        fail?(): any;
+    };
+    refs: {
+        img: unknown;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {
+    isLoaded: import('vue').ComputedRef<boolean>;
+    imageEl: any;
+    imageIns: unknown;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    load: (...args: any[]) => any;
+    click: () => any;
+    error: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onLoad?: (...args: any[]) => any;
+    onClick?: () => any;
+    onError?: () => any;
+}>, {
+    fetchpriority: "high" | "low" | "auto";
+    retryMax: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    img: unknown;
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,53 @@
+import { VirtualListInst, VirtualListProps } from 'naive-ui';
+import { Ref, StyleValue } from 'vue';
+import { IfAny } from '@vueuse/core';
+import { RPromiseContent, Stream } from '../utils/data';
+declare const _default: <T extends NonNullable<VirtualListProps["items"]>[number], PF extends ((d: T[]) => any[])>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onRetry?: (then: () => void) => any;
+        readonly onNext?: (then: () => void) => any;
+        readonly onReset?: () => any;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onReset" | "onRetry" | "onNext"> & {
+        source: {
+            data: RPromiseContent<any, T[]>;
+            isEnd?: boolean;
+            reloadable?: boolean;
+        } | Stream<T> | Array<T>;
+        itemHeight: number;
+        listProp?: Partial<VirtualListProps>;
+        goBottom?: boolean;
+        itemResizable?: boolean;
+        dataProcessor?: PF;
+        style?: StyleValue;
+        class?: any;
+    } & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        scrollTop: import('vue').WritableComputedRef<number, number>;
+        listInstance: Ref<VirtualListInst>;
+    }>): void;
+    attrs: any;
+    slots: Readonly<{
+        default(props: {
+            height: number;
+            data: {
+                item: IfAny<ReturnType<PF>[number], T, ReturnType<PF>[number]>;
+                index: number;
+            };
+        }): any;
+    }> & {
+        default(props: {
+            height: number;
+            data: {
+                item: IfAny<ReturnType<PF>[number], T, ReturnType<PF>[number]>;
+                index: number;
+            };
+        }): any;
+    };
+    emit: ((evt: "retry", then: () => void) => void) & ((evt: "next", then: () => void) => void) & ((evt: "reset") => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

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

@@ -0,0 +1,18 @@
+import { LoadingProps } from 'vant';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Partial<LoadingProps>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Partial<LoadingProps>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,41 @@
+import { PopupProps } from 'vant';
+import { StyleValue } from 'vue';
+type __VLS_Props = Partial<PopupProps & {
+    noBorder?: boolean;
+    useTrulyShow: boolean;
+    style?: StyleValue;
+}>;
+type __VLS_PublicProps = {
+    'show': boolean;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default(): void;
+    }> & {
+        default(): void;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {
+    zIndex: import('vue').ComputedRef<number>;
+    trulyShow: import('vue').ShallowRef<boolean, boolean>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:show": (value: boolean) => any;
+    closed: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:show"?: (value: boolean) => any;
+    onClosed?: () => any;
+}>, {
+    position: import('vant').PopupPosition;
+    noBorder: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,34 @@
+declare const _default: <T extends {
+    name: string;
+    title: string;
+    queries?: Record<string, string>;
+}>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, never> & {
+        items: T[];
+        routerBase: string;
+    } & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: Readonly<{
+        default(arg: {
+            itemName: T;
+        }): any;
+        left(): any;
+        right(): any;
+        bottom(): any;
+    }> & {
+        default(arg: {
+            itemName: T;
+        }): any;
+        left(): any;
+        right(): any;
+        bottom(): any;
+    };
+    emit: {};
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

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

@@ -0,0 +1,23 @@
+type __VLS_Props = {
+    text?: string;
+    ellipsis?: number;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    text: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};