delta-comic-core 0.0.1

package/dist/plugin.d.ts

@@ -0,0 +1,189 @@
+import { ContentPageLike, ItemCardComp, ViewLayoutComp } from './struct/content';
+import { ProcessInstance } from './struct/image';
+import { CommentRow } from './struct/comment';
+import { UserCardComp } from './struct/user';
+import { RStream } from './utils/data';
+import { Item, RawItem } from './struct/item';
+import { Component } from 'vue';
+export interface PluginConfig {
+    name: string;
+    content?: PluginConfigContent;
+    image?: PluginConfigImage;
+    api?: Record<string, PluginConfigApi>;
+    user?: PluginConfigUser;
+    auth?: PluginConfigAuth;
+    otherProgress?: {
+        call: (setDescription: (description: string) => void) => PromiseLike<any>;
+        name: string;
+    }[];
+    onBooted?(ins: PluginDefineResult): PromiseLike<void> | void;
+    search?: PluginConfigSearch;
+}
+export interface PluginConfigUser {
+    edit: Component;
+    card: UserCardComp;
+    /**
+     * 1. download
+     * 2. (auto)clear cloud
+     * 3. upload
+    */
+    syncFavourite?: {
+        download: () => PromiseLike<Item[]>;
+        upload: (items: RawItem[]) => PromiseLike<any>;
+    };
+}
+export interface PluginConfigSearch {
+    /**
+    * @description
+    * key: id
+    */
+    methods?: Record<string, PluginConfigSearchMethod>;
+    tabbar?: PluginConfigSearchTabbar[];
+    categories?: PluginConfigSearchCategory[];
+}
+export interface PluginConfigSearchCategory {
+    title: string;
+    namespace: string;
+    search: {
+        methodId: string;
+        input: string;
+        sort: string;
+    };
+}
+export interface PluginConfigSearchTabbar {
+    title: string;
+    id: string;
+    comp: Component<{
+        isActive: boolean;
+        tabbar: PluginConfigSearchTabbar;
+    }>;
+}
+export interface PluginConfigSearchMethod {
+    name: string;
+    sorts: {
+        text: string;
+        value: string;
+    }[];
+    defaultSort: string;
+    getStream(input: string, sort: string): RStream<Item>;
+    getAutoComplete(input: string, signal: AbortSignal): PromiseLike<{
+        text: string;
+        value: string;
+    }[]>;
+}
+export interface PluginConfigApi {
+    forks: () => (PromiseLike<string[]> | string[]);
+    /**
+     * error -> 不可用
+     * other -> 可用并比对时间
+    */
+    test: (fork: string, signal: AbortSignal) => PromiseLike<void>;
+}
+export interface PluginConfigImage {
+    /**
+     * @description
+     * key: namespace
+     * value: url
+     * 与`Image.setFork(name, key, value)`等价
+    */
+    forks: Record<string, string[]>;
+    test: string;
+    /**
+     * @description
+     * key: reference name
+     * value: process function
+     * 与`Image.setProcess(name, key, value)`等价
+    */
+    process?: Record<string, ProcessInstance['func']>;
+}
+export interface PluginConfigContent {
+    /**
+     * @description
+     * key: contentType
+     * value: component
+     * 与`ContentPage.setItemCard(key, value)`等价
+    */
+    itemCard?: Record<string, ItemCardComp>;
+    /**
+     * @description
+     * key: contentType
+     * value: component
+     * 与`Comment.setCommentRow(key, value)`等价
+    */
+    commentRow?: Record<string, CommentRow>;
+    /**
+     * @description
+     * key: contentType
+     * value: component
+     * 与`ContentPage.setViewLayout(key, value)`等价
+    */
+    layout?: Record<string, ViewLayoutComp>;
+    /**
+     * @description
+     * key: name
+     * value: ContentPage
+     * 与`ContentPage.setContentPage(key, value)`等价
+     * _不需要提供viewLayout_
+    */
+    contentPage?: Record<string, ContentPageLike>;
+}
+export type PluginConfigAuthFormType = {
+    info: string;
+    placeholder?: string;
+    /**
+     * @default true
+    */
+    required?: boolean;
+} & ({
+    type: 'string';
+    patten?: RegExp;
+    defaultValue?: string;
+} | {
+    type: 'number';
+    range?: [number, number];
+    float?: boolean;
+    defaultValue?: number;
+} | {
+    type: 'radio';
+    selects: {
+        label: string;
+        value: string;
+    }[];
+    comp: 'radio' | 'select';
+    defaultValue?: string;
+} | {
+    type: 'checkbox';
+    selects: {
+        label: string;
+        value: string;
+    }[];
+    comp: 'checkbox' | 'multipleSelect';
+    defaultValue?: string[];
+} | {
+    type: 'switch';
+    close?: string;
+    open?: string;
+    defaultValue?: boolean;
+} | {
+    type: 'date';
+    defaultValue?: number;
+});
+export type PluginConfigAuthFormResult<T extends PluginConfigAuthFormType> = T['type'] extends 'string' ? string : T['type'] extends 'number' ? number : T['type'] extends 'radio' ? string : T['type'] extends 'checkbox' ? string[] : T['type'] extends 'switch' ? boolean : T['type'] extends 'date' ? number : never;
+export type PluginConfigAuthMethod = {
+    form<T extends Record<string, PluginConfigAuthFormType>>(form: T): Promise<{
+        [x in keyof T]: PluginConfigAuthFormResult<T[x]>;
+    }>;
+    /**
+     * sandbox: "allow-forms allow-modals allow-orientation-lock allow-popups-to-escape-sandbox  allow-pointer-lock"
+    */
+    website(url: string): Window;
+};
+export interface PluginConfigAuth {
+    signUp: (by: PluginConfigAuthMethod) => PromiseLike<any>;
+    logIn: (by: PluginConfigAuthMethod) => PromiseLike<any>;
+    passSelect: () => PromiseLike<'signUp' | 'logIn' | false>;
+}
+export declare const definePlugin: (config: PluginConfig | ((safe: boolean) => PluginConfig)) => void;
+export type PluginDefineResult = {
+    api?: Record<string, string | undefined | false>;
+};

package/dist/stores/temp.d.ts

@@ -0,0 +1,23 @@
+import { Reactive } from 'vue';
+export declare const useTemp: import('pinia').StoreDefinition<"core:temp", Pick<{
+    $apply: <T extends object>(id: string, def: () => T) => Reactive<T>;
+    $has: (id: string) => boolean;
+    $onlyGet: <T extends object>(id: string) => Reactive<T>;
+    $applyRaw: <T extends object>(id: string, def: () => T) => T;
+    $hasRaw: (id: string) => boolean;
+    $onlyGetRaw: <T extends object>(id: string) => Reactive<T>;
+}, never>, Pick<{
+    $apply: <T extends object>(id: string, def: () => T) => Reactive<T>;
+    $has: (id: string) => boolean;
+    $onlyGet: <T extends object>(id: string) => Reactive<T>;
+    $applyRaw: <T extends object>(id: string, def: () => T) => T;
+    $hasRaw: (id: string) => boolean;
+    $onlyGetRaw: <T extends object>(id: string) => Reactive<T>;
+}, never>, Pick<{
+    $apply: <T extends object>(id: string, def: () => T) => Reactive<T>;
+    $has: (id: string) => boolean;
+    $onlyGet: <T extends object>(id: string) => Reactive<T>;
+    $applyRaw: <T extends object>(id: string, def: () => T) => T;
+    $hasRaw: (id: string) => boolean;
+    $onlyGetRaw: <T extends object>(id: string) => Reactive<T>;
+}, "$apply" | "$has" | "$onlyGet" | "$applyRaw" | "$hasRaw" | "$onlyGetRaw">>;

package/dist/struct/comment.d.ts

@@ -0,0 +1,55 @@
+import { Struct, MetaData, RStream } from '../utils/data';
+import { Component } from 'vue';
+import { uni } from '.';
+import { default as dayjs } from 'dayjs';
+import { User } from './user';
+export interface RawComment {
+    sender: {
+        name: string;
+        user?: any;
+    };
+    content: {
+        type: 'string' | 'html';
+        text: string;
+    };
+    time: number;
+    id: string;
+    childrenCount: number;
+    likeCount: number;
+    isLiked: boolean;
+    reported: boolean;
+    $$plugin: string;
+    $$meta?: MetaData;
+    isTop: boolean;
+}
+export type CommentRow = Component<{
+    comment: Comment;
+    item: uni.item.Item;
+    parentComment?: Comment;
+    onClick?: ((c: Comment) => any);
+}>;
+export declare abstract class Comment extends Struct<RawComment> implements RawComment {
+    private static commentRow;
+    static setCommentRow(ct_: uni.content.ContentType_, component: CommentRow): string;
+    static getCommentRow(ct_: uni.content.ContentType_): uni.comment.CommentRow;
+    constructor(v: RawComment);
+    abstract sender: User;
+    content: {
+        type: 'string' | 'html';
+        text: string;
+    };
+    time: number;
+    $time(): dayjs.Dayjs;
+    id: string;
+    childrenCount: number;
+    likeCount: number;
+    isTop: boolean;
+    isLiked: boolean;
+    reported: boolean;
+    $$plugin: string;
+    $$meta?: MetaData;
+    abstract like(signal?: AbortSignal): PromiseLike<boolean>;
+    abstract report(signal?: AbortSignal): PromiseLike<any>;
+    abstract sendComment(text: string, signal?: AbortSignal): PromiseLike<any>;
+    abstract children: RStream<Comment>;
+}

package/dist/struct/content.d.ts

@@ -0,0 +1,70 @@
+import { Component, StyleValue } from 'vue';
+import { RStream } from '../utils/data';
+import { uni } from '.';
+import { PluginConfigSearchCategory, PluginConfigSearchTabbar } from '../plugin';
+import * as item from './item';
+import * as ep from './ep';
+import * as comment from './comment';
+export type PreloadValue = item.Item | undefined;
+export type ContentPageLike = new (preload: PreloadValue, id: string, ep: string) => ContentPage;
+export declare abstract class ContentPage<T extends object = any> {
+    id: string;
+    ep: string;
+    private static viewLayout;
+    static setViewLayout(ct_: ContentType_, component: ViewLayoutComp): string;
+    static getViewLayout(ct_: ContentType_): uni.content.ViewLayoutComp;
+    static tabbar: import('vue').ShallowReactive<Map<string, PluginConfigSearchTabbar[]>>;
+    static setTabbar(plugin: string, ...tabbar: PluginConfigSearchTabbar[]): void;
+    static getTabbar(plugin: string): PluginConfigSearchTabbar[];
+    static categories: import('vue').ShallowReactive<Map<string, PluginConfigSearchCategory[]>>;
+    static setCategories(plugin: string, ...categories: PluginConfigSearchCategory[]): void;
+    static getCategories(plugin: string): PluginConfigSearchCategory[];
+    private static itemCard;
+    static setItemCard(ct_: ContentType_, component: ItemCardComp): string;
+    static getItemCard(ct_: ContentType_): uni.content.ItemCardComp;
+    private static contentPage;
+    static setContentPage(contentType: ContentType_, page: ContentPageLike): void;
+    static getContentPage(contentType: ContentType_): uni.content.ContentPageLike;
+    static toContentType(ct: ContentType_): ContentType;
+    static toContentTypeString(ct: ContentType_): string;
+    constructor(preload: PreloadValue, id: string, ep: string);
+    abstract contentType: ContentType;
+    pid: import('../utils/data').PromiseWithResolvers<string>;
+    preload: import('vue').ShallowRef<item.Item, item.Item>;
+    detail: import('../utils/data').PromiseWithResolvers<item.Item>;
+    union: import('vue').ComputedRef<item.Item>;
+    recommends: import('../utils/data').PromiseWithResolvers<item.Item[]>;
+    abstract comments: RStream<comment.Comment>;
+    eps: import('../utils/data').PromiseWithResolvers<ep.Ep[]>;
+    abstract loadAll(): Promise<any>;
+    abstract reloadAll(): Promise<any>;
+    abstract plugin: string;
+    abstract loadAllOffline(): Promise<T>;
+    abstract exportOffline(save: T): Promise<any>;
+    abstract ViewComp: ViewComp;
+}
+export type ViewComp = Component<{
+    page: ContentPage;
+    isFullScreen: boolean;
+}>;
+export interface ContentType {
+    plugin: string;
+    name: string;
+}
+/**
+ * @example "bika:comic"
+ * "91video:video"
+ * "jm:comic"
+ */
+export type ContentType_ = ContentType | string;
+export type ViewLayoutComp = Component<{
+    page: ContentPage;
+}>;
+export type ItemCardComp = Component<{
+    item: uni.item.Item;
+    freeHeight?: boolean;
+    disabled?: boolean;
+    type?: 'default' | 'big' | 'small';
+    class?: any;
+    style?: StyleValue;
+}>;

package/dist/struct/ep.d.ts

@@ -0,0 +1,14 @@
+import { Struct, MetaData } from '../utils/data';
+export interface RawEp {
+    name: string;
+    index: string;
+    $$plugin: string;
+    $$meta?: MetaData;
+}
+export declare class Ep extends Struct<RawEp> implements RawEp {
+    name: string;
+    index: string;
+    $$plugin: string;
+    $$meta?: MetaData;
+    constructor(v: RawEp);
+}

package/dist/struct/image.d.ts

@@ -0,0 +1,44 @@
+import { Struct, MetaData } from '../utils/data';
+export interface ProcessInstance {
+    fullName: string;
+    plugin: string;
+    referenceName: string;
+    func: (nowPath: string, img: Image) => Promise<[path: string, exit: string]>;
+}
+export interface ProcessStep {
+    referenceName: string;
+    ignoreExit?: boolean;
+}
+type ProcessStep_ = ProcessStep | string;
+export interface RawImage {
+    $$plugin: string;
+    $$meta?: MetaData;
+    path: string;
+    forkNamespace: string;
+    processSteps?: ProcessStep_[];
+}
+export declare class Image extends Struct<RawImage> implements RawImage {
+    aspect?: {
+        width: number;
+        height: number;
+    };
+    static processInstances: import('vue').ShallowReactive<Map<string, ProcessInstance>>;
+    static setProcess(plugin: string, referenceName: string, func: ProcessInstance['func']): void;
+    static fork: import('vue').ShallowReactive<Map<string, string[]>>;
+    static activeFork: import('vue').ShallowReactive<Map<string, string>>;
+    static setFork(plugin: string, namespace: string, fork: string[]): void;
+    static is(value: unknown): value is Image;
+    static create(v: RawImage, aspect?: {
+        width: number;
+        height: number;
+    }): Image;
+    private constructor();
+    forkNamespace: string;
+    path: string;
+    processSteps: ProcessStep[];
+    $$meta?: MetaData;
+    $$plugin: string;
+    getUrl(): Promise<string>;
+}
+export type Image_ = string | Image;
+export {};

package/dist/struct/index.d.ts

@@ -0,0 +1,14 @@
+import * as _item from "./item";
+import * as _image from "./image";
+import * as _content from "./content";
+import * as _ep from "./ep";
+import * as _comment from "./comment";
+import * as _user from "./user";
+export declare namespace uni {
+    export import user = _user;
+    export import comment = _comment;
+    export import content = _content;
+    export import image = _image;
+    export import item = _item;
+    export import ep = _ep;
+}

package/dist/struct/item.d.ts

@@ -0,0 +1,56 @@
+import { Struct, MetaData } from '../utils/data';
+import { default as dayjs } from 'dayjs';
+import { ContentType, ContentType_ } from './content';
+import { Ep, RawEp } from './ep';
+import * as image from "./image";
+export interface RawItem {
+    cover: image.RawImage;
+    title: string;
+    id: string;
+    categories: string[];
+    author: string[];
+    viewNumber?: number;
+    likeNumber?: number;
+    commentNumber?: number;
+    isLiked?: boolean;
+    updateTime?: number;
+    customIsAI?: boolean;
+    contentType: ContentType_;
+    length: string;
+    epLength: string;
+    $$plugin: string;
+    $$meta: MetaData;
+    description?: string;
+    thisEp: RawEp;
+    commentSendable: boolean;
+}
+export declare abstract class Item extends Struct<RawItem> implements RawItem {
+    abstract like(signal?: AbortSignal): PromiseLike<boolean>;
+    abstract report(signal?: AbortSignal): PromiseLike<any>;
+    abstract sendComment(text: string, signal?: AbortSignal): PromiseLike<any>;
+    static is(value: unknown): value is Item;
+    cover: image.RawImage;
+    get $cover(): image.Image;
+    title: string;
+    id: string;
+    categories: string[];
+    author: string[];
+    viewNumber?: number;
+    likeNumber?: number;
+    commentNumber?: number;
+    isLiked?: boolean;
+    description?: string;
+    updateTime?: number;
+    get $updateTime(): dayjs.Dayjs;
+    contentType: ContentType;
+    length: string;
+    epLength: string;
+    $$plugin: string;
+    $$meta: any;
+    thisEp: RawEp;
+    get $thisEp(): Ep;
+    constructor(v: RawItem);
+    commentSendable: boolean;
+    customIsAI?: boolean;
+    get $isAi(): boolean;
+}

package/dist/struct/user.d.ts

@@ -0,0 +1,21 @@
+import { uni } from '.';
+import { Image, RawImage } from './image';
+import { Component } from 'vue';
+export interface RawUser {
+    avatar?: RawImage;
+    name: string;
+    id: string;
+}
+export declare abstract class User {
+    static userBase: import('vue').ShallowReactive<Map<string, uni.user.User>>;
+    static userEditorBase: import('vue').ShallowReactive<Map<string, Component>>;
+    constructor(v: RawUser);
+    avatar?: Image;
+    name: string;
+    id: string;
+    abstract customUser: object;
+}
+export type UserCardComp = Component<{
+    user: uni.user.User;
+    isSmall?: boolean;
+}>;

package/dist/symbol.d.ts

@@ -0,0 +1,3 @@
+export declare const symbol: Readonly<{
+    thisNamespace: "core";
+}>;

package/dist/utils/data.d.ts

@@ -0,0 +1,123 @@
+import { Raw, Ref } from 'vue';
+export declare class Struct<TRaw extends object> {
+    protected $$raw: TRaw;
+    toJSON(): TRaw;
+    constructor($$raw: TRaw);
+}
+export type MetaData = Record<string | number, any>;
+/**
+ * 扩展内容的`Promise`，可视为普通`Promise`使用
+*/
+export declare class PromiseContent<T, TPF extends any = T> implements PromiseLike<T> {
+    private promise;
+    private processor;
+    private static _this;
+    static isPromiseContent(value: unknown): value is PromiseContent<any>;
+    static fromPromise<T, TP = T>(promise: Promise<T>, processor?: (val: T) => TP): RPromiseContent<T, TP>;
+    /**
+     * 使用`PromiseContent.fromPromise`或`PromiseContent.fromAsyncFunction`代替`new PromiseContent`
+    */
+    private constructor();
+    private loadPromise;
+    /**
+     * 对`this.data.value`做出处理，多次调用仅最后一次生效
+    */
+    setProcessor<TP>(processor: (val: T) => TP): RPromiseContent<T, TP>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined): Promise<T | TResult>;
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): Promise<TResult1 | TResult2>;
+    finally(onfinally?: (() => void) | null | undefined): Promise<T>;
+    data: import('vue').ShallowRef<TPF, TPF>;
+    isLoading: import('vue').ShallowRef<boolean, boolean>;
+    isError: import('vue').ShallowRef<boolean, boolean>;
+    errorCause: import('vue').ShallowRef<Error, Error>;
+    isEmpty: import('vue').ShallowRef<boolean, boolean>;
+    static fromAsyncFunction<T extends (...args: any[]) => Promise<any>>(asyncFunction: T): (...args: Parameters<T>) => RPromiseContent<Awaited<ReturnType<T>>>;
+    static resolve<T>(data: T): RPromiseContent<Awaited<T>, Awaited<T>>;
+    static withResolvers<T>(isLoading?: boolean): PromiseWithResolvers<T>;
+}
+export type PromiseWithResolvers<T> = {
+    content: RPromiseContent<T>;
+    reject: (reason?: any) => void;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reset: (isLoading?: boolean) => void;
+};
+export type RPromiseContent<T, PTF = T> = Raw<PromiseContent<T, PTF>>;
+type RawGenerator<T> = (abortSignal: AbortSignal, that: Stream<T>) => (IterableIterator<T[], void, Stream<T>> | AsyncIterableIterator<T[], void, Stream<T>>);
+/**
+ * _(网络)_ 数据流
+*/
+export type RStream<T> = Raw<Stream<T>>;
+/**
+ * 可迭代 _(网络)_ 数据流
+*/
+export declare class Stream<T> implements AsyncIterableIterator<T[], void> {
+    /**
+     * 使用`Stream.create`代替`new Stream`
+     */
+    private constructor();
+    private static _this;
+    static isStream(stream: any): stream is Stream<any>;
+    static create<T>(generator: RawGenerator<T>): RStream<T>;
+    [x: symbol]: any;
+    private abortController;
+    private generator;
+    private _setupData;
+    /** 初始存在的数据(置顶) */
+    setupData(data: T[]): this;
+    next(igRequesting?: boolean): Promise<IteratorResult<T[], void>>;
+    return(): Promise<IteratorResult<T[], void>>;
+    throw(e?: any): Promise<IteratorResult<T[], void>>;
+    /** 重置 */
+    reset(): void;
+    /** 重试 */
+    retry(): Promise<IteratorResult<T[], void>>;
+    /** 一次性全部加载 */
+    nextToDone(): Promise<T[]>;
+    /** 停止正在进行的请求 */
+    stop(): void;
+    [Symbol.asyncIterator](): this;
+    /** 错误(如果有) */
+    error: import('vue').ShallowRef<void | Error, void | Error>;
+    /** 数据 */
+    data: Ref<T[]>;
+    /** 数据 */
+    get _data(): T[];
+    /** 当前页 */
+    page: import('vue').ShallowRef<number, number>;
+    /** 当前页 */
+    get _page(): number;
+    /** 总页数 */
+    pages: import('vue').ShallowRef<number, number>;
+    /** 总页数 */
+    get _pages(): number;
+    /** 总条目数 */
+    total: import('vue').ShallowRef<number, number>;
+    /** 总条目数 */
+    get _total(): number;
+    /** 单页条目数 */
+    pageSize: import('vue').ShallowRef<number, number>;
+    /** 单页条目数 */
+    get _pageSize(): number;
+    /** 数据当前总数 */
+    length: import('vue').ComputedRef<number>;
+    /** 数据当前总数 */
+    get _length(): number;
+    /** 是否正在网络请求 */
+    isRequesting: import('vue').ShallowRef<boolean, boolean>;
+    /** 是否正在网络请求 */
+    get _isRequesting(): boolean;
+    /** 是否全部获取完成 */
+    isDone: import('vue').ShallowRef<boolean, boolean>;
+    /** 是否全部获取完成 */
+    get _isDone(): boolean;
+    /** 是否无结果 */
+    isNoData: import('vue').ComputedRef<boolean>;
+    /** 是否无结果 */
+    get _isNoData(): boolean;
+    /** 是否当前为空 */
+    isEmpty: import('vue').ComputedRef<boolean>;
+    /** 是否当前为空 */
+    get _isEmpty(): boolean;
+}
+export declare const callbackToPromise: <T = void>(fn: (resolve: (result: T | PromiseLike<T>) => void) => any) => Promise<T>;
+export {};

package/dist/utils/delay.d.ts

@@ -0,0 +1 @@
+export declare const delay: (time: number) => Promise<void>;

package/dist/utils/eventBus.d.ts

@@ -0,0 +1,34 @@
+import { PluginConfig } from '../plugin';
+import { uni } from '../struct';
+export type EventBus = {
+    networkError_unauth: any;
+    networkError_response: any;
+    networkError_emptyData: any;
+    networkError_request: any;
+};
+export declare const eventBus: import('mitt').Emitter<EventBus>;
+export type SharedFunctions = {
+    /** 重复调用需缓存(自行实现)(可不缓存) */ getUser(): PromiseLike<object>;
+    getRandomProvide(signal: AbortSignal): PromiseLike<uni.item.Item[]>;
+    addPlugin(ins: PluginConfig): void;
+    addRecent(item: uni.item.Item | uni.item.RawItem): PromiseLike<any>;
+};
+export declare class SharedFunction {
+    private static sharedFunctions;
+    static define<TKey extends keyof SharedFunctions>(fn: SharedFunctions[TKey], plugin: string, name: TKey): SharedFunctions[TKey];
+    static call<TKey extends keyof SharedFunctions>(name: TKey, ...args: Parameters<SharedFunctions[TKey]>): {
+        fn: SharedFunctions[keyof SharedFunctions];
+        plugin: string;
+        result: ReturnType<SharedFunctions[TKey]>;
+    }[];
+    static callRandom<TKey extends keyof SharedFunctions>(name: TKey, ...args: Parameters<SharedFunctions[TKey]>): {
+        fn: SharedFunctions[keyof SharedFunctions];
+        plugin: string;
+        result: ReturnType<SharedFunctions[TKey]>;
+    };
+    static callWitch<TKey extends keyof SharedFunctions>(name: TKey, plugin: string, ...args: Parameters<SharedFunctions[TKey]>): {
+        fn: SharedFunctions[keyof SharedFunctions];
+        plugin: string;
+        result: ReturnType<SharedFunctions[TKey]>;
+    };
+}

package/dist/utils/image.d.ts

@@ -0,0 +1,5 @@
+import { ImagePreviewOptions } from 'vant';
+export declare const showImagePreview: (images: string[], config?: Omit<ImagePreviewOptions, "images" | "teleport">) => {
+    isShowing: import('vue').ComputedRef<boolean>;
+    close: () => void;
+};

package/dist/utils/layout.d.ts

@@ -0,0 +1,8 @@
+import { MaybeRefOrGetter, ComputedRef } from 'vue';
+/**
+ * @description
+ * 对于所有弹出层，使用其确定`z-index`
+ * 在组件内使用时，卸载组件 _`(onUnmounted)`_ 会自动清理，否则需要主动调用`return[2]`清理
+ *
+*/
+export declare const useZIndex: (show: MaybeRefOrGetter<boolean>) => [index: ComputedRef<number>, isLast: ComputedRef<boolean>, stopUse: () => void];