@signal24/vue-foundation 4.30.7 → 4.30.8

package/dist/src/components/overlay-container.d.ts

@@ -1,53 +1,45 @@
-import type { Writable } from 'type-fest';
-import { type AllowedComponentProps, type ComponentInternalInstance, type ComponentPublicInstance, type ComputedOptions, type MethodOptions, type Raw, type VNode, type VNodeProps } from 'vue';
+import { type AllowedComponentProps, type Component, type ComponentCustomProps, type ComponentInternalInstance, type Raw, type VNode, type VNodeProps } from 'vue';
 import type { OverlayAnchorOptions } from './overlay-types';
-interface OverlayOptions<C extends OverlayComponent, R extends ComponentReturn<C>> {
+interface OverlayOptions<C extends Component, R extends ComponentReturn<C>> {
     anchor?: OverlayAnchorOptions;
     onCallback?: (result: R) => void | Promise<boolean>;
 }
-export interface OverlayInjection<C extends OverlayComponent, R extends ComponentReturn<C>> {
+export interface OverlayInjection<C extends Component> {
     id: string;
-    component: OverlayComponentUnwrapped<C>;
-    props: OverlayComponentProps<C>;
-    options: OverlayOptions<C, R>;
+    component: Raw<C>;
+    props: {
+        callback?: () => void;
+    } & OverlayComponentProps<C>;
+    options: OverlayOptions<C, any>;
     vnode: VNode;
     wrapperVnode?: VNode;
 }
 export declare const OverlayContainer: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
     [key: string]: any;
 }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-export type Vue__ComponentPublicInstanceConstructor<T extends ComponentPublicInstance<Props, RawBindings, D, C, M> = ComponentPublicInstance<any>, Props = any, RawBindings = any, D = any, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions> = {
-    __isFragment?: never;
-    __isTeleport?: never;
-    __isSuspense?: never;
-    new (...args: any[]): T;
-};
-export type ObjectComponentConfig<T extends Vue__ComponentPublicInstanceConstructor> = T extends Vue__ComponentPublicInstanceConstructor<infer P> ? P : never;
-export type ObjectComponentProps<T extends Vue__ComponentPublicInstanceConstructor> = Writable<Omit<ObjectComponentConfig<T>['$props'], keyof VNodeProps | keyof AllowedComponentProps>>;
-type ObjectOrDefault<T> = T extends object ? T : PropsWithCallback<{}>;
-export type OverlayComponent = Vue__ComponentPublicInstanceConstructor | ((props: any) => any);
-export type OverlayComponentConfig<T> = T extends Vue__ComponentPublicInstanceConstructor ? {
-    props: ObjectComponentProps<T>;
-    component: Raw<T>;
-} : T extends (props: infer P) => any ? {
-    props: Omit<ObjectOrDefault<P>, keyof VNodeProps | keyof AllowedComponentProps>;
-    component: T;
-} : never;
-export type OverlayComponentUnwrapped<T extends OverlayComponent> = OverlayComponentConfig<T>['component'];
-export type OverlayComponentProps<T extends OverlayComponent> = OverlayComponentConfig<T>['props'];
-interface PropsWithCallback<T> {
-    callback?: (result: T) => void;
-}
-type ComponentReturn<M extends OverlayComponent> = OverlayComponentProps<M> extends PropsWithCallback<infer R> ? R : never;
 export type AnyComponentPublicInstance = {
     $?: ComponentInternalInstance;
 };
-export declare function createOverlayInjection<C extends OverlayComponent, R extends ComponentReturn<C>>(component: C, props: OverlayComponentProps<C>, options?: OverlayOptions<C, R>): OverlayInjection<C, R>;
+type ExtractComponentProps<C> = C extends new (...args: any) => any ? InstanceType<C>['$props'] : C extends (props: infer P, ...args: any) => any ? P : C extends {
+    __props?: infer P;
+} ? P : never;
+type CleanProps<P> = {
+    [K in keyof P as K extends keyof (VNodeProps & AllowedComponentProps & ComponentCustomProps) ? never : string extends K ? never : K]: P[K];
+};
+type HasCallbackProp<C> = CleanProps<ExtractComponentProps<C>> extends {
+    callback: (result: any) => void;
+} ? true : false;
+type OverlayComponent<C extends Component> = HasCallbackProp<C> extends true ? C : never;
+type ComponentReturn<C> = CleanProps<ExtractComponentProps<C>> extends {
+    callback: (result: infer R) => void;
+} ? R : never;
+type OverlayComponentProps<C> = CleanProps<ExtractComponentProps<C>>;
+export declare function createOverlayInjection<C extends Component, R extends ComponentReturn<C>>(component: OverlayComponent<C>, props: OverlayComponentProps<C>, options?: OverlayOptions<C, R>): OverlayInjection<C>;
 export declare function dismissOverlayInjectionByInstance(instance: AnyComponentPublicInstance): void;
 export declare function dismissOverlayInjectionByInternalInstance(instance: ComponentInternalInstance): void;
 export declare function dismissOverlayInjectionByVnode(vnode: VNode): boolean;
 export declare function dismissOverlayInjectionById(id: string): boolean;
-export declare function removeOverlayInjection(injection: OverlayInjection<any, any>): void;
-export declare function presentOverlay<C extends OverlayComponent, R extends ComponentReturn<C>>(component: C, props: Omit<OverlayComponentProps<C>, 'callback'>, options?: OverlayOptions<C, R>): Promise<R | undefined>;
-export declare function updateOverlayProps<C extends OverlayComponent>(injection: OverlayInjection<C, any>, props: Partial<Omit<OverlayComponentProps<C>, 'callback'>>): Promise<void>;
+export declare function removeOverlayInjection(injection: OverlayInjection<any>): void;
+export declare function presentOverlay<C extends Component, R extends ComponentReturn<C>>(component: OverlayComponent<C>, props: Omit<OverlayComponentProps<C>, 'callback'>, options?: OverlayOptions<C, R>): Promise<R | undefined>;
+export declare function updateOverlayProps<C extends Component>(injection: OverlayInjection<C>, props: Partial<Omit<OverlayComponentProps<C>, 'callback'>>): Promise<void>;
 export {};