@extclp/vexip-ui/dist/common/config/src/props.d.ts

A Vue 3 UI library, Highly customizability, full TypeScript, performance pretty good

import { App, CSSProperties, ComponentObjectPropsOptions, MaybeRef, PropType } from 'vue';
import { LocaleConfig, LocaleNames } from './locale';
import { AnyFunction, EnsureValue, Expand, MaybeFunction, VoidFunction } from './types';
export type PropsOptions = Record<string, Record<string, unknown>>;
interface PropsConfig<T = any> {
    /**
     * The default value of the prop
     */
    default: T | (() => T) | null;
    /**
     * Whether the prop is a function type
     *
     * @default false
     */
    isFunc?: boolean;
    /**
     * Whether the prop is not configurable
     *
     * @default false
     */
    static?: boolean;
    /**
     * Whether the prop is required
     *
     * @default false
     */
    required?: boolean;
    /**
     * The validator for the prop, decide whether the value of the prop is valid
     *
     * @param value the value of the prop
     */
    validator?: (value: T) => any;
}
type PropsConfigOptions<T> = {
    [K in keyof T]?: PropsConfig<EnsureValue<T[K]>> | EnsureValue<T[K]> | (() => EnsureValue<T[K]>) | null;
};
export declare const PROVIDED_PROPS = "__vxp-provided-props";
/**
 * Provide a props config for under components.
 *
 * @param props props config
 * @param app the app of Vue, will use app.provide if specify
 */
export declare function configProps<T>(props: MaybeRef<T>, app?: App): void;
export declare function useProps<T extends Record<string, any>>(name: string, sourceProps: T, config?: PropsConfigOptions<T>): { [P in keyof T]-?: Exclude<T[P], undefined>; };
export declare function useHookProps<T extends Record<any, any>>(props: T, defaults: {
    [K in keyof T]: T[K] | null;
}): { [P in keyof T]-?: Exclude<T[P], undefined>; };
export declare const booleanProp: {
    type: BooleanConstructor;
    default: null;
};
export declare const booleanStringProp: {
    type: (BooleanConstructor | StringConstructor)[];
    default: null;
};
export declare const booleanNumberProp: {
    type: (NumberConstructor | BooleanConstructor)[];
    default: null;
};
type CommonExcludedProps = 'inherit' | 'value' | 'checked' | 'active' | 'visible' | 'label' | 'options' | 'name';
type ExcludeProps<P, E extends string = never, I extends string = never> = Exclude<CommonExcludedProps, I> | Exclude<E, I> | (P extends I ? never : P extends `on${Capitalize<string>}` ? P : never);
type PostProps<T, E extends string> = Omit<{
    [P in keyof T]: MaybeFunction<T[P]>;
}, E>;
/**
 * Create a configurable props
 *
 * @param T the type of import('vue').ExtractPropTypes
 * @param E the props should force exclude
 * @param I the props should force include
 */
export type ConfigurableProps<T, E extends string = never, I extends string = never> = PostProps<{
    [P in keyof T]?: P extends I ? T[P] : P extends `on${Capitalize<string>}` ? never : T[Exclude<P, CommonExcludedProps | E>];
}, ExcludeProps<keyof T, E, I>>;
type VexipProps<T> = {
    [P in keyof T]: T[P] extends PropType<infer I> ? PropType<I & {}> : T[P] extends {
        type: PropType<infer I>;
    } ? PropType<I & {}> : T[P];
};
export declare function wrapProps<T extends ComponentObjectPropsOptions>(props: T): Expand<T>;
export declare function buildProps<T extends ComponentObjectPropsOptions>(props: T): Expand<VexipProps<{
    inherit: {
        type: BooleanConstructor;
        default: null;
    };
} & T>>;
export declare function omitProps<T extends ComponentObjectPropsOptions, K extends keyof T>(props: T, keys: K[]): Expand<Omit<T, K>>;
export declare function omitProps<T extends ComponentObjectPropsOptions, K extends keyof T, E extends ComponentObjectPropsOptions>(props: T, keys: K[], extra: E): Expand<Omit<T, K> & E>;
export type ComponentSize = 'small' | 'default' | 'large';
export declare const sizeProp: PropType<ComponentSize>;
export declare function createSizeProp(defaultValue?: MaybeRef<ComponentSize>): {
    default: () => ComponentSize;
    validator: (value: ComponentSize) => boolean;
};
export type ComponentState = 'default' | 'success' | 'error' | 'warning';
export declare const stateProp: PropType<ComponentState>;
export declare function createStateProp(defaultValue?: MaybeRef<ComponentState>): {
    default: () => ComponentState;
    validator: (value: ComponentState) => boolean;
};
type MaybeArray<T> = T | T[];
export type ClassType = string | Record<string, any> | Array<string | Record<string, any>>;
export type StyleType = string | CSSProperties | Array<string | CSSProperties>;
export declare const classProp: PropType<ClassType>;
export declare const styleProp: PropType<StyleType>;
type ForceBoolean<T> = true extends T ? Exclude<T, boolean> | boolean : false extends T ? Exclude<T, boolean> | boolean : T;
type ForceBooleanDeep<T> = T extends unknown ? {
    [K in keyof T]: ForceBoolean<T[K]>;
} : never;
type SplitAndCombo<T, O = T> = T extends unknown ? [T] | (SplitAndCombo<Exclude<O, T>> extends infer U extends any[] ? U extends U ? [ForceBoolean<T | U[number]>] : never : never) : never;
type GenerateEvent<T extends any[], Others extends any[], R = any> = T extends unknown ? Others extends never ? (value: T[0]) => R : (value: T[0], ...args: Others) => R : never;
/**
 * Split and combo the first parameter of the given function
 *
 * @example
 * ```ts
 * // origin function
 * type Fn = (value: string | number | boolean) => void
 *
 * // after transform
 * type After =
 *  | ((value: string | number | boolean) => void)
 *  | ((value: string | number) => void)
 *  | ((value: string | boolean) => void)
 *  | ((value: number | boolean) => void)
 *  | ((value: string) => void)
 *  | ((value: number) => void)
 *  | ((value: boolean) => void)
 * ```
 */
export type EventListener<T extends AnyFunction> = Expand<ForceBooleanDeep<SplitAndCombo<Parameters<T>[0]>>> extends infer F extends any[] ? Parameters<T> extends [unknown, ...infer Others] ? GenerateEvent<F, Others, ReturnType<T>> : GenerateEvent<F, never, ReturnType<T>> : never;
export declare function eventProp<F extends AnyFunction = VoidFunction>(): PropType<MaybeArray<F>>;
export declare function emitEvent<A extends any[]>(handlers: MaybeArray<(...args: A) => void> | undefined, ...args: A): void;
export declare function localeProp<N extends LocaleNames>(_name: N): PropType<Partial<LocaleConfig[N]>>;
export declare const valueProp: {
    type: (NumberConstructor | BooleanConstructor | StringConstructor)[];
    default: null;
};
export declare const valuesProp: {
    type: PropType<MaybeArray<string | number | boolean>>;
    default: null;
};
export declare const iconProp: (ObjectConstructor | FunctionConstructor)[];
export declare function createIconProp(defaultValue?: Record<any, any> | AnyFunction | null): {
    isFunc: boolean;
    default: AnyFunction | Record<any, any> | null;
};
export {};