@schwarzdavid/ui-kit 0.0.1-alpha.2 → 0.0.1-alpha.20

package/dist/main.d.ts

@@ -0,0 +1,365 @@
+import { AllowedComponentProps } from 'vue';
+import { Component } from 'vue';
+import { ComponentCustomProps } from 'vue';
+import { ComponentOptionsMixin } from 'vue';
+import { ComponentProps } from 'vue-component-type-helpers';
+import { ComponentProvideOptions } from 'vue';
+import { DefineComponent } from 'vue';
+import { FunctionPlugin } from 'vue';
+import { HasRequiredKeys } from 'type-fest';
+import { MaybeRefOrGetter } from 'vue';
+import { PartialDeep } from 'type-fest';
+import { Promisable } from 'type-fest';
+import { PublicProps } from 'vue';
+import { Ref } from 'vue';
+import { VNodeProps } from 'vue';
+
+declare const __VLS_base: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    close: () => any;
+    submit: () => any;
+    "update:modelValue": (value: boolean) => any;
+    "update:stage": (stage: SheetStage) => any;
+    opened: () => any;
+    closed: () => any;
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+    onSubmit?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    "onUpdate:stage"?: ((stage: SheetStage) => any) | undefined;
+    onOpened?: (() => any) | undefined;
+    onClosed?: (() => any) | undefined;
+}>, {
+    form: boolean;
+    title: string;
+    persistent: boolean;
+    stage: SheetStage;
+    translateTitle: boolean;
+    expandable: boolean;
+    closable: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_base_2: DefineComponent<__VLS_Props_2, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    close: () => any;
+    submit: () => any;
+    "update:modelValue": (value: boolean) => any;
+    "update:stage": (stage: SheetStage) => any;
+    opened: () => any;
+    closed: () => any;
+}, string, PublicProps, Readonly<__VLS_Props_2> & Readonly<{
+    onClose?: (() => any) | undefined;
+    onSubmit?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    "onUpdate:stage"?: ((stage: SheetStage) => any) | undefined;
+    onOpened?: (() => any) | undefined;
+    onClosed?: (() => any) | undefined;
+}>, {
+    width: DialogWidth;
+    form: boolean;
+    persistent: boolean;
+    stage: SheetStage;
+    translateTitle: boolean;
+    expandable: boolean;
+    closable: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_export: DefineComponent<{}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+declare const __VLS_export_2: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+
+declare const __VLS_export_3: __VLS_WithSlots_2<typeof __VLS_base_2, __VLS_Slots_2>;
+
+declare type __VLS_Props = {
+    modelValue: boolean;
+    stage?: SheetStage;
+    title?: string;
+    translateTitle?: boolean;
+    expandable?: boolean;
+    closable?: boolean;
+    persistent?: boolean;
+    form?: boolean;
+};
+
+declare type __VLS_Props_2 = {
+    modelValue: boolean;
+    title: string;
+    translateTitle?: boolean;
+    width?: DialogWidth;
+    closable?: boolean;
+    persistent?: boolean;
+    form?: boolean;
+    expandable?: boolean;
+    stage?: SheetStage;
+};
+
+declare type __VLS_Slots = {
+    default?: () => unknown;
+    preview?: () => unknown;
+    header?: () => unknown;
+    actions?: () => unknown;
+};
+
+declare type __VLS_Slots_2 = {
+    default?: () => unknown;
+    preview?: () => unknown;
+    header?: () => unknown;
+    actions?: () => unknown;
+};
+
+declare type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithSlots_2<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare interface ConfirmDialogBaseProps {
+    title: string;
+    translateTitle?: boolean;
+    confirmCta?: Partial<DialogCta>;
+    rejectCta?: Partial<DialogCta>;
+    throwOnReject?: boolean;
+    permanent?: boolean;
+    width?: DialogWidth;
+    highlightCta?: 'confirm' | 'reject' | false;
+    level?: ConfirmDialogLevel;
+}
+
+export declare type ConfirmDialogComponentContent<C extends Component = Component> = DialogProps<ComponentProps<C>> & ConfirmDialogBaseProps & {
+    component: C;
+};
+
+export declare enum ConfirmDialogLevel {
+    DEFAULT = "primary",
+    WARNING = "warning",
+    DANGER = "error"
+}
+
+export declare type ConfirmDialogProps<C extends Component = Component> = ConfirmDialogComponentContent<C> | ConfirmDialogTextContent;
+
+export declare interface ConfirmDialogTextContent extends ConfirmDialogBaseProps {
+    content: string;
+    translateContent?: boolean;
+}
+
+declare interface CreateToastQueueEntry {
+    type: ToastType;
+    message: string;
+    translateMessage: boolean;
+    timeout: number | false;
+    action?: ToastAction;
+    resolve(triggered: boolean): void;
+}
+
+export declare function createUIKit(options?: CreateUIKitOptions): FunctionPlugin<unknown[]>;
+
+export declare type CreateUIKitOptions = PartialDeep<Omit<PluginOptions, 'components'>> & {
+    components?: {
+        dialog?: Partial<PluginDialogComponentOptions>;
+        toast?: Component;
+    };
+};
+
+export declare interface DialogActionCta extends DialogCta {
+    action(): unknown;
+}
+
+export declare interface DialogComposable {
+    info(title: string, content: string): Promise<null>;
+    info<T = void, C extends Component = Component>(options: InfoDialogProps<T, C>): Promise<T extends void ? null : (T | null)>;
+    confirm(title: string, content: string, level?: ConfirmDialogLevel): Promise<boolean>;
+    confirm<C extends Component = Component>(options: ConfirmDialogProps<C>): Promise<boolean>;
+    form<T, R = T, Required extends boolean = false, C extends Component = Component>(options: FormDialogProps<T, R, Required, C>): Promise<Required extends true ? R : R | null>;
+}
+
+export declare interface DialogCta {
+    text: string;
+    translateText: boolean;
+}
+
+export declare interface DialogEntryContext<Data = unknown, Value = unknown> {
+    readonly id: string;
+    readonly data: Data;
+    resolve(value: Value): void;
+    reject(reason?: unknown): void;
+}
+
+export declare interface DialogFormContext {
+    submit(): Promise<void>;
+    loading: Readonly<Ref<boolean>>;
+}
+
+export declare type DialogFormFinish<T> = () => Promisable<T>;
+
+declare type DialogProps<T extends object> = PropsRequired<OwnProps<T>> extends true ? {
+    props: OwnProps<T>;
+} : {
+    props?: OwnProps<T>;
+};
+
+export declare interface DialogValueCta<T> extends DialogCta {
+    value: T;
+}
+
+export declare type DialogWidth = 'sm' | 'md' | 'lg' | number;
+
+export declare type FormDialogAction<T, R> = (value: T) => Promise<R>;
+
+export declare interface FormDialogBaseProps<T, R = T, Required extends boolean = false, C extends Component = Component> {
+    title: string;
+    translateTitle?: boolean;
+    width?: DialogWidth;
+    saveCta?: Partial<DialogCta>;
+    abortCta?: Partial<DialogCta>;
+    component: C;
+    initialValue?: MaybeRefOrGetter<T>;
+    action?: FormDialogAction<T, R>;
+    required?: Required;
+}
+
+export declare type FormDialogInjectedProp = 'modelValue' | 'onUpdate:modelValue' | 'toolbar';
+
+declare type FormDialogModelCheck<T, C extends Component> = unknown extends T ? unknown : 'modelValue' extends keyof ComponentProps<C> ? [T] extends [NonNullable<ComponentProps<C>['modelValue']>] ? unknown : {
+    component: never;
+} : unknown;
+
+export declare type FormDialogProps<T, R = T, Required extends boolean = false, C extends Component = Component> = DialogProps<Omit<ComponentProps<C>, FormDialogInjectedProp>> & FormDialogModelCheck<T, C> & FormDialogBaseProps<T, R, Required, C>;
+
+declare interface InfoDialogBaseProps<T> {
+    title: string;
+    translateTitle?: boolean;
+    additionalCta?: InteractiveDialogCta<T>[];
+    defaultCta?: Partial<DialogCta> | false;
+    width?: DialogWidth;
+}
+
+export declare type InfoDialogComponentContent<T = void, C extends Component = Component> = DialogProps<ComponentProps<C>> & InfoDialogBaseProps<T> & {
+    component: C;
+};
+
+export declare type InfoDialogProps<T = void, C extends Component = Component> = InfoDialogComponentContent<T, C> | InfoDialogTextContent<T>;
+
+export declare interface InfoDialogTextContent<T> extends InfoDialogBaseProps<T> {
+    content: string;
+    translateContent?: boolean;
+}
+
+export declare type InteractiveDialogCta<T> = DialogActionCta | DialogValueCta<T>;
+
+export declare type LoadingAction = (...args: never[]) => unknown;
+
+export declare interface LoadingComposable<A extends LoadingAction> {
+    loading: Readonly<Ref<boolean>>;
+    action(...args: Parameters<A>): Promise<Awaited<ReturnType<A>>>;
+}
+
+declare type OwnProps<T extends object> = Omit<T, keyof VNodeProps | keyof AllowedComponentProps | keyof ComponentCustomProps>;
+
+export declare interface PluginComponentOptions {
+    dialog: PluginDialogComponentOptions;
+    toast: Component;
+}
+
+export declare interface PluginDialogComponentOptions {
+    info: Component;
+    confirm: Component;
+    form: Component;
+}
+
+export declare interface PluginDialogOptions {
+    closeOnOverlayClick: boolean;
+}
+
+export declare type PluginI18nMessageKey = 'save' | 'cancel' | 'close' | 'yes' | 'no' | 'saveFailed' | 'unknownError' | 'expand' | 'collapse';
+
+export declare interface PluginI18nOptions {
+    messages: Record<PluginI18nMessageKey, string>;
+}
+
+export declare interface PluginLoadingOptions {
+    delay: number | false;
+    overlay: boolean;
+}
+
+export declare interface PluginOptions {
+    loading: PluginLoadingOptions;
+    toast: PluginToastOptions;
+    dialog: PluginDialogOptions;
+    i18n: PluginI18nOptions;
+    components: PluginComponentOptions;
+}
+
+export declare interface PluginToastOptions {
+    timeout: number;
+    errorTimeout: number | false;
+}
+
+declare type PropsRequired<P extends object> = string extends keyof P ? false : HasRequiredKeys<P>;
+
+export declare type SheetStage = 'preview' | 'content' | 'fullscreen';
+
+export declare interface ToastAction {
+    text: string;
+    translateText?: boolean;
+    handler?: () => unknown;
+}
+
+export declare interface ToastComposable {
+    info: ToastFunction;
+    warn: ToastFunction;
+    error: ToastFunction;
+    success: ToastFunction;
+}
+
+export declare interface ToastEntryContext {
+    readonly entry: ToastEntryData;
+    close(): void;
+    trigger(): void;
+}
+
+export declare type ToastEntryData = Omit<ToastQueueEntry, 'resolve'>;
+
+export declare type ToastFunction = (message: string, options?: Partial<ToastOptions>) => Promise<boolean>;
+
+export declare interface ToastOptions {
+    timeout: number | false;
+    translateMessage: boolean;
+    action?: ToastAction;
+}
+
+export declare interface ToastQueueEntry extends CreateToastQueueEntry {
+    id: string;
+}
+
+export declare enum ToastType {
+    SUCCESS = "success",
+    INFO = "info",
+    WARNING = "warning",
+    ERROR = "error"
+}
+
+export declare const UiBottomSheet: typeof __VLS_export_2;
+
+export declare const UiKitOutlet: typeof __VLS_export;
+
+export declare const UiResponsiveDialog: typeof __VLS_export_3;
+
+export declare function useDialog(): DialogComposable;
+
+export declare function useDialogEntry<Data, Value = unknown>(): DialogEntryContext<Data, Value>;
+
+export declare function useDialogForm<T>(finish: DialogFormFinish<T>): DialogFormContext;
+
+export declare function useLoading<A extends LoadingAction>(actionCallback: A, options?: Partial<PluginLoadingOptions>): LoadingComposable<A>;
+
+export declare function useLoadingOverlay(): Ref<boolean>;
+
+export declare function useToast(): ToastComposable;
+
+export declare function useToastEntry(): ToastEntryContext;
+
+export { }