@overlastic/vue 0.8.0 → 0.8.3

package/dist/index.d.ts

@@ -1,25 +1,52 @@
 import * as vue_demi from 'vue-demi';
 import { Ref, AppContext, App } from 'vue-demi';
-import * as _overlastic_core from '@overlastic/core';
-import { Deferred, ImperativeOverlay, GlobalMountOptions, MountOptions } from '@overlastic/core';
 import * as vue from 'vue';
-import { Component, PropType, VNode } from 'vue';
+import { PropType, VNode, Component, VNodeProps } from 'vue';
+import { Deferred, MountOptions, ImperativeOverlay } from '@overlastic/core';
+
+declare const Field: vue.DefineComponent<{
+    is: {
+        type: PropType<string | number | VNode | Component>;
+        default: string;
+    };
+}, () => string | number | VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}> | null, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+    is: {
+        type: PropType<string | number | VNode | Component>;
+        default: string;
+    };
+}>>, {
+    is: string | number | VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }> | Component;
+}, {}>;
+
+declare const OverlaysProvider: vue_demi.DefineComponent<{}, () => vue_demi.VNode<vue_demi.RendererNode, vue_demi.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.VNodeProps & vue_demi.AllowedComponentProps & vue_demi.ComponentCustomProps, Readonly<vue_demi.ExtractPropTypes<{}>>, {}, {}>;
 
 interface PromptifyEvents {
     /**
-     * reject event name used by the template
+     * cancel event name used by the template
+     *
+     * @default 'cancel'
+     */
+    cancel?: string;
+    /**
+     * confirm event name used by the template
      *
-     * @default 'reject'
+     * @default 'confirm'
      */
-    reject?: string;
+    confirm?: string;
     /**
-     * resolve event name used by the template
+     * confirm event name used by the template
      *
-     * @default 'resolve'
+     * @default 'close'
      */
-    resolve?: string;
+    close?: string;
 }
-interface ExtendOverlayOptions {
+interface UseDisclosureOptions {
     /** animation duration to avoid premature destruction of components */
     duration?: number;
     /** whether to set visible to true immediately */
@@ -41,11 +68,13 @@ interface ExtendOverlayOptions {
      */
     automatic?: boolean;
 }
-interface ExtendOverlayReturn {
-    /** the notification reject, modify visible, and destroy it after the duration ends */
-    reject: (reason?: any) => void;
-    /** the notification resolve, modify visible, and destroy it after the duration ends */
-    resolve: (value?: any) => void;
+interface UseDisclosureReturn {
+    /** the notification cancel, modify visible, and destroy it after the duration ends */
+    cancel: (reason?: any) => void;
+    /** the notification confirm, modify visible, and destroy it after the duration ends */
+    confirm: (value?: any) => void;
+    /** the notification confirm, modify visible, and destroy it after the duration ends */
+    close: () => void;
     /** destroy the current instance (immediately) */
     vanish: () => void;
     /** visible control popup display and hide */
@@ -55,61 +84,39 @@ interface ExtendOverlayReturn {
 }
 /**
  * get overlay layer meta information
- * @function reject  the notification reject, modify visible, and destroy it after the duration ends
- * @function resolve the notification resolve, modify visible, and destroy it after the duration ends
+ * @function cancel  the notification cancel, modify visible, and destroy it after the duration ends
+ * @function confirm the notification confirm, modify visible, and destroy it after the duration ends
  * @function vanish destroy the current instance (immediately)
  * @field visible control overlay display and hide
  */
-declare function useExtendOverlay(options?: ExtendOverlayOptions): ExtendOverlayReturn;
+declare function useDisclosure(options?: UseDisclosureOptions): UseDisclosureReturn;
 
 type AbstractFn = abstract new (...args: any) => any;
 
-type InjectionHolder<Component extends AbstractFn, Resolved> = [Component, ImperativeOverlay<InstanceType<Component>['$props'], Resolved>];
-declare function useOverlayHolder<Component extends AbstractFn, Resolved = any>(component: Component, options?: Omit<GlobalMountOptions, 'appContext'>): InjectionHolder<Component, Resolved>;
-
-interface Options {
-    render: (instance: Component, props: any) => void;
-    vanish: (instance: Component) => void;
-}
-declare function useOverlayInject<Component extends AbstractFn, Resolved>(Instance: Component): _overlastic_core.ImperativeOverlay<InstanceType<Component>["$props"], Resolved, Options>;
+type KnownKeys<T> = {
+    [K in keyof T]: T[K] extends unknown ? (unknown extends T[K] ? never : K) : never;
+}[keyof T];
+type PickKnown<T> = Pick<T, KnownKeys<T>>;
+type ExtractEvent<T extends AbstractFn> = Parameters<Required<InstanceType<T>['$props']>['onConfirm']>[0];
+type ExtractProps<T extends AbstractFn> = PickKnown<Omit<InstanceType<T>['$props'], keyof VNodeProps | `on${string}` | 'visible'>>;
+declare function useOverlay<Comp extends AbstractFn, Resolved = ExtractEvent<Comp>>(Instance: Comp, options?: MountOptions<{
+    type?: 'inject';
+}>): ImperativeOverlay<ExtractProps<Comp>, Resolved>;
+declare function useOverlay<Comp extends AbstractFn, Resolved = ExtractEvent<Comp>>(Instance: Comp, options?: MountOptions<{
+    type?: 'holder';
+}>): [Comp, ImperativeOverlay<ExtractProps<Comp>, Resolved>];
 
 interface VMountOptions {
     /** current app context */
     appContext?: AppContext;
 }
 
-declare const defineOverlay: <Component extends AbstractFn, Resolved = any>(instance: Component, options?: MountOptions<VMountOptions> | undefined) => ImperativeOverlay<InstanceType<Component>['$props'], Resolved, VMountOptions>;
-declare const renderOverlay: <Component extends AbstractFn, Resolved = any>(instance: Component, props?: InstanceType<Component>['$props'] | undefined, options?: MountOptions<VMountOptions> | undefined) => Promise<Resolved>;
-
-declare const Field: vue.DefineComponent<{
-    is: {
-        type: PropType<string | number | VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }> | Component>;
-        default: string;
-    };
-}, () => string | number | VNode<vue.RendererNode, vue.RendererElement, {
-    [key: string]: any;
-}> | null, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-    is: {
-        type: PropType<string | number | VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }> | Component>;
-        default: string;
-    };
-}>>, {
-    is: string | number | VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }> | Component;
-}, {}>;
-
-declare const OverlaysProvider: vue_demi.DefineComponent<{}, () => vue_demi.VNode<vue_demi.RendererNode, vue_demi.RendererElement, {
-    [key: string]: any;
-}>, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.VNodeProps & vue_demi.AllowedComponentProps & vue_demi.ComponentCustomProps, Readonly<vue_demi.ExtractPropTypes<{}>>, {}, {}>;
+declare const defineOverlay: <Component extends AbstractFn, Resolved = any>(instance: Component, options?: MountOptions<VMountOptions> | undefined) => ImperativeOverlay<InstanceType<Component>["$props"], Resolved, VMountOptions>;
+declare const renderOverlay: <Component extends AbstractFn, Resolved = any>(instance: Component, props?: InstanceType<Component>["$props"] | undefined, options?: MountOptions<VMountOptions> | undefined) => Promise<Resolved>;
 
 declare function install(app: App): void;
 declare const unoverlay: {
     install: typeof install;
 };
 
-export { type ExtendOverlayOptions, type ExtendOverlayReturn, Field, type InjectionHolder, OverlaysProvider, unoverlay as default, defineOverlay, install, renderOverlay, useExtendOverlay, useOverlayHolder, useOverlayInject };
+export { Field, OverlaysProvider, type UseDisclosureOptions, type UseDisclosureReturn, unoverlay as default, defineOverlay, install, renderOverlay, useDisclosure, useOverlay };