vue-mount-plugin 3.0.0 → 4.0.0-beta.0

package/dist/index.d.ts

@@ -1,42 +1,287 @@
 import type { App } from 'vue-demi';
-import { createVNode } from 'vue-demi';
+import type { AppContext } from 'vue-demi';
+import { ComponentPublicInstance } from 'vue-demi';
+import { Plugin as Plugin_2 } from 'vue-demi';
+import { Ref } from 'vue-demi';
 import type { VNode } from 'vue-demi';
 import type { VNodeProps } from 'vue-demi';
-import { Vue2 } from 'vue-demi';
 
-export declare type Component = CreateVNodeParameters['0'];
+export declare function addClass(element: Element, className: string): void;
 
-export declare type CreateVNodeParameters = Parameters<typeof createVNode>;
+export { App }
+
+export { AppContext }
+
+export declare function appendTo(element: Element, target: Element | ShadowRoot | string | null): void;
+
+export declare function capitalize(str: string): string;
+
+export declare function clearSingletons(): void;
+
+export declare type Component = any;
+
+export { ComponentPublicInstance }
+
+export declare interface ContextOptions {
+    router?: unknown;
+    store?: unknown;
+    i18n?: unknown;
+    [key: string]: unknown;
+}
+
+export declare function createElement(tagName?: string, attributes?: Record<string, string>): HTMLElement;
+
+export declare function createInstanceId(): string;
+
+export declare function createMount<T = any>(component: Component, options?: MountOptions): MountInstance<T>;
 
 export declare type Data = Record<string, unknown>;
 
-declare class Mount {
-    vNode: VNode | typeof Vue2 | null;
-    target: Element | ShadowRoot;
-    options: Options;
-    seed: number;
-    constructor(component: Component, options?: Options);
-    createVM(component: Component, { props, children, patchFlag, dynamicProps, isBlockNode, app, context, parent }?: Options): any;
-    mount(): void;
+export declare class EventEmitter {
+    private events;
+    on(event: string, handler: Listener): this;
+    off(event: string, handler?: Listener): this;
+    emit(event: string, ...args: any[]): this;
+    has(event: string): boolean;
+    clear(): void;
+    eventNames(): string[];
+}
+
+export declare function eventToPropName(event: string): string;
+
+export declare function getActiveInstanceIds(): string[];
+
+export declare function getCurrentComponentContext(componentInstance: any): ContextOptions;
+
+export declare function getGlobalConfig(): GlobalConfig;
+
+export declare function getInstanceById(id: string): MountBase | undefined;
+
+export declare function getInstances(): MountBase[];
+
+export declare function getSingleton(key: string | symbol): MountInstance | undefined;
+
+export declare function getSingletonKey(component: any, singleton?: boolean | string): string | symbol | undefined;
+
+export declare function getSingletonKeys(): (string | symbol)[];
+
+export declare interface GlobalConfig extends Partial<MountOptions> {
+    zIndex?: number;
+    container?: string | Element | null;
+    transition?: string | TransitionOptions;
+    context?: ContextOptions;
+    installed?: boolean;
+}
+
+export declare const globalConfig: GlobalConfig;
+
+export declare function hasSingleton(key: string | symbol): boolean;
+
+export declare function inheritVue2Context(parent: any, options: MountOptions): ContextOptions;
+
+export declare function inheritVue3Context(app: App | undefined, _options?: MountOptions): {
+    appContext?: App['_context'];
+    provides?: Record<string, unknown>;
+};
+
+export declare function isBrowser(): boolean;
+
+export declare function isInDOM(element: Element): boolean;
+
+export declare function isMounted(id: string): boolean;
+
+export declare function isNodeEnv(): boolean;
+
+export declare interface KeepAliveOptions {
+    enabled?: boolean;
+    include?: string | RegExp | string[];
+    exclude?: string | RegExp | string[];
+    max?: number;
+}
+
+export declare interface LifecycleHooks {
+    onBeforeMount?: (instance: MountInstance) => void;
+    onMounted?: (instance: MountInstance) => void;
+    onBeforeUnmount?: (instance: MountInstance) => void;
+    onUnmounted?: (instance: MountInstance) => void;
+}
+
+export declare type Listener = (...args: any[]) => void;
+
+export declare type Listeners = Record<string, Listener | Listener[]>;
+
+export declare function mergeWithGlobalConfig<T extends Record<string, any>>(options: T): T;
+
+export declare function mount<T = any>(component: Component, options?: MountOptions): MountInstance<T>;
+
+export declare abstract class MountBase implements MountInstance {
+    readonly id: string;
+    options: MountOptions;
+    mounted: boolean;
+    el: HTMLElement | null;
+    abstract vm: ComponentPublicInstance | null;
+    protected _eventEmitter: EventEmitter;
+    protected _promise: Promise<any>;
+    protected _resolve: (value: any) => void;
+    protected _reject: (error: any) => void;
+    protected _component: any;
+    protected _autoCreatedTarget: boolean;
+    protected _hidden: boolean;
+    protected _destroyed: boolean;
+    protected _singletonKey: string | symbol | undefined;
+    constructor(component: any, options?: MountOptions);
+    protected abstract _createVM(): void;
+    protected abstract _mountVM(): void;
+    protected abstract _unmountVM(): void;
+    protected abstract _updateVM(): void;
+    show(): this;
+    hide(): this;
     unmount(): void;
+    destroy: () => void;
+    remove: () => void;
+    setProps(props: Record<string, any>): this;
+    on(event: string, handler: Listener): this;
+    off(event: string, handler?: Listener): this;
+    emit(event: string, ...args: any[]): this;
+    then<TResult = void>(resolve: (value: any) => TResult): Promise<TResult>;
+    catch<TResult = never>(reject: (error: any) => TResult): Promise<any>;
+    finally(onFinally: () => void): Promise<any>;
+    setTarget(target: string | Element | ShadowRoot): this;
+    setHooks(hooks: LifecycleHooks): this;
+    setSlots(slots: Slots): this;
+    protected _ensureElement(): void;
+    protected _appendElementToDOM(): void;
+    protected _resolvePromise(value?: any): void;
+    protected _rejectPromise(error?: any): void;
+    protected _mergeListenersToProps(listeners: Record<string, Listener>): Record<string, any>;
+    static get instances(): MountBase[];
+    static unmountAll(): void;
+    static getById(id: string): MountBase | undefined;
 }
-export default Mount;
 
-export declare interface Options {
+export declare interface MountInstance<T = ComponentPublicInstance> {
+    vm: T | null;
+    el: HTMLElement | null;
+    mounted: boolean;
+    id: string;
+    options: MountOptions;
+    setProps: (props: Partial<Data>) => MountInstance<T>;
+    show: () => MountInstance<T>;
+    hide: () => MountInstance<T>;
+    unmount: () => void;
+    on: (event: string, handler: Listener) => MountInstance<T>;
+    off: (event: string, handler?: Listener) => MountInstance<T>;
+    emit: (event: string, ...args: any[]) => MountInstance<T>;
+    then: <TResult = void>(resolve: (value: any) => TResult) => Promise<TResult>;
+    setTarget: (target: string | Element | ShadowRoot) => MountInstance<T>;
+    setHooks: (hooks: LifecycleHooks) => MountInstance<T>;
+    setSlots: (slots: Slots) => MountInstance<T>;
+}
+
+export declare interface MountOptions<TContext = ContextOptions> extends LifecycleHooks {
+    target?: string | Element | ShadowRoot | null;
+    tagName?: string;
+    replace?: boolean;
     props?: (Data & VNodeProps) | null;
     children?: unknown;
     patchFlag?: number;
     dynamicProps?: string[] | null;
     isBlockNode?: boolean;
-    target?: Element | ShadowRoot;
-    tagName?: keyof HTMLElementTagNameMap;
+    listeners?: Listeners;
+    on?: Listeners;
+    slots?: Slots;
     app?: App;
-    context?: Data & {
-        router: unknown;
-        store: unknown;
-        i18n: unknown;
-    };
+    context?: TContext;
     parent?: unknown;
+    ref?: Ref<ComponentPublicInstance | null>;
+    zIndex?: number;
+    singleton?: boolean | string;
+    transition?: string | TransitionOptions;
+    delay?: number;
+    keepAlive?: KeepAliveOptions | boolean;
+}
+
+export declare const MountPlugin: Plugin_2;
+
+export declare interface MountPluginOptions extends GlobalConfig {
+    name?: string;
+}
+
+export declare class MountVue2 extends MountBase {
+    vm: ComponentPublicInstance | null;
+    private _vue2Instance;
+    constructor(component: any, options?: MountOptions);
+    protected _createVM(): void;
+    protected _mountVM(): void;
+    protected _unmountVM(): void;
+    protected _updateVM(): void;
+}
+
+export declare class MountVue3 extends MountBase {
+    vm: ComponentPublicInstance | null;
+    private _vNode;
+    constructor(component: any, options?: MountOptions);
+    protected _createVM(): void;
+    protected _mountVM(): void;
+    protected _unmountVM(): void;
+    protected _updateVM(): void;
 }
 
+export { Ref }
+
+export declare function removeClass(element: Element, className: string): void;
+
+export declare function removeElement(element: Element): void;
+
+export declare function removeSingleton(key: string | symbol): void;
+
+export declare function resetGlobalConfig(): void;
+
+export declare function resolveTarget(target: string | Element | ShadowRoot | null | undefined): Element | ShadowRoot | null;
+
+export declare function setGlobalConfig(config: Partial<GlobalConfig>): void;
+
+export declare function setSingleton(key: string | symbol, instance: MountInstance): void;
+
+export declare function setZIndex(element: HTMLElement, zIndex: number | undefined): void;
+
+export declare interface Slots {
+    default?: VNode | VNode[];
+    [key: string]: VNode | VNode[] | undefined;
+}
+
+export declare interface TransitionOptions {
+    name?: string;
+    appear?: boolean;
+    css?: boolean;
+    enterClass?: string;
+    leaveClass?: string;
+    enterActiveClass?: string;
+    leaveActiveClass?: string;
+    enterToClass?: string;
+    leaveToClass?: string;
+}
+
+export declare function unmountAll(): void;
+
+export declare function useMount(): UseMountReturn;
+
+export declare interface UseMountReturn {
+    instances: Ref<MountInstance[]>;
+    mount: <T = any>(component: any, options?: MountOptions) => MountInstance<T>;
+    unmount: (instance: MountInstance) => void;
+    unmountAll: () => void;
+    getById: (id: string) => MountInstance | undefined;
+    hasInstances: () => boolean;
+    count: () => number;
+}
+
+export declare function useSingleton(): UseSingletonReturn;
+
+export declare interface UseSingletonReturn {
+    getOrCreate: <T = any>(key: string, component: any, options?: MountOptions) => MountInstance<T>;
+}
+
+export { VNode }
+
 export { }