x-next 0.0.0-alpha.7 → 0.0.0-alpha.70

package/dist/_utils/number.d.ts

@@ -0,0 +1,193 @@
+/**
+ * 将给定的常量字符串类型拓展为不区分大小写的任意组合
+ */
+export type AnyCase<S> = string extends S ? string : S extends `${infer F1}${infer F2}${infer R}` ? `${Uppercase<F1> | Lowercase<F1>}${Uppercase<F2> | Lowercase<F2>}${AnyCase<R>}` : S extends `${infer F}${infer R}` ? `${Uppercase<F> | Lowercase<F>}${AnyCase<R>}` : '';
+export declare const numberRE: RegExp;
+/**
+ * 检测给定的值是否可以通过 parseFlat 或 Number 方法转为数字
+ *
+ * 开启严格模式则通过正则以更严格的方法判断
+ *
+ * @param value 需要检测的值
+ * @param strict 是否为严格模式
+ *
+ * @returns 值是否可以转为数字
+ */
+export declare function isValidNumber(value: unknown, strict?: boolean): boolean;
+/**
+ * 将给定的值转成数字，NaN 的情况将会处理成 0
+ *
+ * @param value 需要转换的值
+ *
+ * @returns 转换后的数字
+ */
+export declare function toNumber(value: unknown): number;
+/**
+ * 为给定的整数开头填充 0，直至满足指定的长度
+ *
+ * @param number 需要处理的整数
+ * @param length 填充至的长度
+ *
+ * @returns 填充后的字面值
+ */
+export declare function padStartZeros(number: number, length: number): string;
+/**
+ * 将小于 10 整数 N 变成 `0N` 的字符串，方法不会对入参校验
+ *
+ * @param number 需要处理的整数
+ *
+ * @returns 填充后的字面值
+ */
+export declare function doubleDigits(number: number): string;
+/**
+ * 返回数字的小数位数
+ *
+ * @param number 指定的数字
+ *
+ * @returns 数字的小数位数
+ */
+export declare function decimalLength(number: number | string): number;
+/**
+ * Return decimal length of a number
+ *
+ * @param number The input number
+ * @deprecated Using `decimalLength` to replace it
+ */
+export declare function digitLength(number: number | string): number;
+/**
+ * 将给定的数字格式化为指定的位阶
+ *
+ * @param number 需要格式化的数字
+ * @param segment 分隔的位数，默认为 3
+ * @param separator 分隔的符号，默认为 ','
+ *
+ * @returns 格式化后的字面值
+ */
+export declare function segmentNumber(number: number | string, segment?: number, separator?: string): string;
+/**
+ * 将给定的实数保留一定的小数
+ *
+ * @param number 需要处理的实数
+ * @param decimal 需要保留的小数
+ *
+ * @returns 保留小数后的值
+ */
+export declare function toFixed(number: number, decimal: number): number;
+/**
+ * 将给定的实数扩大一定的倍数并保留一定的小数
+ *
+ * @param number 要处理的实数
+ * @param multiple 要扩大的倍数
+ * @param decimal 要保留的小数
+ *
+ * @returns 扩大并保留小数后的值
+ */
+export declare function multipleFixed(number: number, multiple: number, decimal: number): number;
+/**
+ * 根据临界值对给定的数字进行舍入
+ *
+ * @param number 需要舍入的数
+ * @param criticalValue 舍入的临界值 (0 ~ 1)，达到临界值进位反之舍弃
+ *
+ * @returns 舍入后的值
+ */
+export declare function round(number: number, criticalValue: number): number;
+/**
+ * 将给定的数字限定在指定的范围内
+ *
+ * @param number 需要限定范围的数
+ * @param min 边界最小值，包含该值
+ * @param max 边界最大值，包含该值
+ *
+ * @returns 限定在范围内的值
+ */
+export declare function boundRange(number: number | string, min: number, max: number): number;
+/**
+ * 将给定的被除数和除数，不断的取余直至达到次数限制或余数小于除数，返回系列余数
+ *
+ * @param number 被除数，需大于 0
+ * @param divideBy 除数，需大于 1
+ * @param limit 次数限制，默认为 0，小于 1 则不作限制
+ *
+ * @returns 相除过程的系列余数
+ */
+export declare function leaveNumber(number: number, divideBy: number, limit?: number): number[];
+/**
+ * 将给定的数字转换为序数词
+ *
+ * @param number 需要转换的数字
+ *
+ * @returns 转换后的序数词
+ */
+export declare function ordinalNumber(number: number): string;
+export type SizeUnitWithAuto = AnyCase<'B' | 'KB' | 'MB' | 'GB' | 'TB' | 'AUTO'>;
+export type SizeUnit = Exclude<SizeUnitWithAuto, AnyCase<'AUTO'>>;
+/**
+ * 根据给定的 Byte 数值，将其格式化成指定单位的大小
+ *
+ * @param byte 需要计算的 Byte 数值
+ * @param unit 格式化的单位
+ * @param precision 结果的精度
+ * @param joinUtil 是否加入单位
+ *
+ * @returns 格式化后的值
+ */
+export declare function formatByteSize(byte: number, unit?: SizeUnitWithAuto): number;
+export declare function formatByteSize(byte: number, unit?: SizeUnitWithAuto, precision?: number): number;
+export declare function formatByteSize(byte: number, unit?: SizeUnitWithAuto, joinUtil?: true): number;
+export declare function formatByteSize(byte: number, unit?: SizeUnitWithAuto, joinUtil?: true, precision?: number): number;
+/**
+ * 在给定的范围内随机一个数
+ *
+ * @param max 最大值
+ * @param min 最小值，默认为 0
+ *
+ * @returns 生成的随机数
+ */
+export declare function random(max: number, min?: number): number;
+/**
+ * 将数字处理为的指定的有效位数
+ *
+ * @param number 需要处理的数字
+ * @param precision 数字的有效位数
+ *
+ * @returns 处理后的数字
+ *
+ * @example
+ * ```ts
+ * toPrecision(0.09999999999999998) === 0.1 // true
+ * ```
+ */
+export declare function toPrecision(number: number | string, precision?: number): number;
+/**
+ * 精确的乘法
+ *
+ * @param numbers 需要依次相乘的数字
+ *
+ * @returns 乘积
+ */
+export declare const times: (...numbers: (number | string)[]) => number;
+/**
+ * 精确的加法
+ *
+ * @param numbers 需要依次相加的数字
+ *
+ * @returns 和
+ */
+export declare const plus: (...numbers: (number | string)[]) => number;
+/**
+ * 精确的减法
+ *
+ * @param numbers 需要依次相减的数字
+ *
+ * @returns 差值
+ */
+export declare const minus: (...numbers: (number | string)[]) => number;
+/**
+ * 精确的除法
+ *
+ * @param numbers 需要依次相除的数字
+ *
+ * @returns 商
+ */
+export declare const divide: (...numbers: (number | string)[]) => number;

package/dist/_utils/omit.d.ts

@@ -0,0 +1,2 @@
+import { Data } from './types';
+export declare const omit: <T extends Data, K extends keyof any>(object: T, path: Array<K>) => Omit<T, K>;

package/dist/_utils/pick.d.ts

@@ -0,0 +1 @@
+export default function pick<T extends object, K extends keyof T>(obj: T, keys: Array<K | string>): Pick<T, K>;

package/dist/_utils/raf.d.ts

@@ -0,0 +1,3 @@
+declare const raf: typeof requestAnimationFrame;
+declare const caf: typeof cancelAnimationFrame;
+export { raf, caf };

package/dist/_utils/responsive-observe.d.ts

@@ -0,0 +1,24 @@
+export type Breakpoint = 'xxl' | 'xl' | 'lg' | 'md' | 'sm' | 'xs';
+export type BreakpointMap = Partial<Record<Breakpoint, string>>;
+export type ScreenMap = Partial<Record<Breakpoint, boolean>>;
+export declare const responsiveArray: Breakpoint[];
+export declare const responsiveMap: BreakpointMap;
+type SubscribeFunc = (screens: ScreenMap, breakpointChecked: Breakpoint) => void;
+type MediaQueryResult = {
+    matches: boolean;
+};
+type MediaQueryListener = (matches: MediaQueryResult) => void;
+declare const responsiveObserve: {
+    matchHandlers: {
+        [key: string]: {
+            mql: MediaQueryList;
+            listener: MediaQueryListener;
+        };
+    };
+    dispatch(pointMap: ScreenMap, breakpointChecked: Breakpoint): boolean;
+    subscribe(func: SubscribeFunc): string;
+    unsubscribe(token: string): void;
+    unregister(): void;
+    register(): void;
+};
+export default responsiveObserve;

package/dist/_utils/style.d.ts

@@ -0,0 +1,3 @@
+export declare function fixedWidth(width: number): Record<string, unknown>;
+export declare function setTransformStyle(value: string): Record<string, unknown>;
+export declare function getStyle(element: HTMLElement | null, prop: string | null): string | number | ((index: number) => string) | CSSRule | ((property: string, value: string | null, priority?: string) => void) | null;

package/dist/_utils/throttle-by-raf.d.ts

@@ -0,0 +1,4 @@
+export declare function throttleByRaf(cb: (...args: any[]) => void): {
+    (...args: any[]): void;
+    cancel(): void;
+};

package/dist/_utils/types.d.ts

@@ -0,0 +1,3 @@
+import { RenderFunction } from 'vue';
+export type Data = Record<string, any>;
+export type RenderContent = string | RenderFunction;

package/dist/_utils/use-prop-or-slot.d.ts

@@ -0,0 +1,7 @@
+import { Slots } from 'vue';
+export default function usePropOrSlot<T = {
+    [key: string]: any;
+}>(props: T, slots: Slots, propName: string): import('vue').ComputedRef<any>;
+export declare function hasPropOrSlot<T = {
+    [key: string]: any;
+}>(props: T, slots: Slots, propName: string): import('vue').ComputedRef<boolean>;

package/dist/_utils/vue-eco.d.ts

@@ -1,5 +1,7 @@
-import { VNodeTypes, VNode, PropType, Component, Slots, Plugin } from 'vue';
+import { VNodeTypes, VNode, PropType, Component, Slots, App, Plugin, DefineComponent, VNodeArrayChildren } from 'vue';
+import { Data } from './types';
 export type SFCWithInstall<T> = T & Plugin;
+type ObjectData = Record<string, unknown>;
 /**
  * @description Vue生态操作封装
  */
@@ -19,10 +21,31 @@ export declare enum ShapeFlags {
 }
 export declare const isElement: (vn: VNode) => boolean;
 export declare const isComponent: (vn: VNode, type?: VNodeTypes) => type is Component;
+export declare const isNamedComponent: (child: VNode, name: string) => boolean;
 export declare const isTextChildren: (child: VNode, children: VNode["children"]) => children is string;
 export declare const isArrayChildren: (vn: VNode, children: VNode["children"]) => children is VNode[];
 export declare const isSlotsChildren: (vn: VNode, children: VNode["children"]) => children is Slots;
+export declare const getChildrenString: (children: VNode[]) => string;
+export declare const isEmptyChildren: (children?: VNode[]) => boolean;
 export declare const getAllElements: (children: VNode[] | undefined, includeText?: boolean) => VNode<import('vue').RendererNode, import('vue').RendererElement, {
     [key: string]: any;
 }>[];
+export declare const getFirstElement: (vn: VNode | VNode[]) => HTMLElement | null;
+export declare const getFirstElementFromVNode: (vn: VNode) => HTMLElement | undefined;
+export declare const getFirstElementFromChildren: (children: VNode[] | undefined) => HTMLElement | undefined;
+export declare const getChildrenArray: (vn: VNode) => VNode[] | undefined;
+export declare const getComponentsFromVNode: (vn: VNode, name: string) => number[];
+export declare const getComponentsFromChildren: (children: VNode[] | undefined, name: string) => number[];
+export declare const getFirstComponent: (children: VNode[] | undefined) => VNode | undefined;
+/**
+ * Remove Fragment
+ * @param nodeList
+ */
+export declare function unFragment(nodeList: VNode[]): VNodeArrayChildren;
+export declare const resolveProps: (vn: VNode) => Data;
+export declare const mergeFirstChild: (children: VNode[] | undefined, extraProps: ObjectData | ((vn: VNode) => ObjectData)) => boolean;
 export declare const withInstall: <T, E extends Record<string, any>>(main: T, extra?: E) => SFCWithInstall<T> & E;
+export declare const generateComponent: <T extends Component | DefineComponent>(name: string, component: T) => T & {
+    install(app: App): void;
+};
+export {};

package/dist/components/_components/icon-hover/index.vue.d.ts

@@ -0,0 +1,38 @@
+import { PropType } from 'vue';
+type Size = 'mini' | 'small' | 'medium' | 'large' | 'huge';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    prefix: {
+        type: StringConstructor;
+    };
+    size: {
+        type: PropType<Size>;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {
+    className: {
+        block: string;
+        element: (className: string) => string;
+        modifier: (className: string) => string;
+        is: (className: string) => string;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    prefix: {
+        type: StringConstructor;
+    };
+    size: {
+        type: PropType<Size>;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    size: Size;
+    disabled: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/_components/input-label/input-label.d.ts

@@ -0,0 +1,56 @@
+import { PropType } from 'vue';
+import { Size } from '../../../_utils/constant';
+import { SelectViewValue } from '../select-view/interface';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    modelValue: PropType<SelectViewValue>;
+    inputValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    enabledInput: BooleanConstructor;
+    formatLabel: PropType<(data?: SelectViewValue) => string>;
+    placeholder: StringConstructor;
+    retainInputValue: BooleanConstructor;
+    disabled: BooleanConstructor;
+    baseCls: StringConstructor;
+    size: PropType<Size>;
+    error: BooleanConstructor;
+    focused: BooleanConstructor;
+    uninjectFormItemContext: BooleanConstructor;
+}>, {
+    inputRef: import('vue').Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+    render: () => VNode;
+}, {}, {}, {
+    focus(): void;
+    blur(): void;
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("focus" | "blur" | "update:inputValue" | "inputValueChange")[], "focus" | "blur" | "update:inputValue" | "inputValueChange", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    modelValue: PropType<SelectViewValue>;
+    inputValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    enabledInput: BooleanConstructor;
+    formatLabel: PropType<(data?: SelectViewValue) => string>;
+    placeholder: StringConstructor;
+    retainInputValue: BooleanConstructor;
+    disabled: BooleanConstructor;
+    baseCls: StringConstructor;
+    size: PropType<Size>;
+    error: BooleanConstructor;
+    focused: BooleanConstructor;
+    uninjectFormItemContext: BooleanConstructor;
+}>> & Readonly<{
+    onFocus?: ((...args: any[]) => any) | undefined;
+    onBlur?: ((...args: any[]) => any) | undefined;
+    "onUpdate:inputValue"?: ((...args: any[]) => any) | undefined;
+    onInputValueChange?: ((...args: any[]) => any) | undefined;
+}>, {
+    error: boolean;
+    disabled: boolean;
+    inputValue: string;
+    focused: boolean;
+    uninjectFormItemContext: boolean;
+    retainInputValue: boolean;
+    enabledInput: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/_components/select-view/interface.d.ts

@@ -0,0 +1,6 @@
+import { TagData } from '../../form-input-tag/interface';
+export interface SelectViewValue extends TagData {
+    value: string | number;
+    label: string;
+    closable: boolean;
+}

package/dist/components/_components/select-view/select-view.d.ts

@@ -0,0 +1,148 @@
+import { PropType } from 'vue';
+import { Data } from '../../../_utils/types';
+import { Size } from '../../../_utils/constant';
+import { SelectViewValue } from './interface';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    modelValue: {
+        type: PropType<SelectViewValue[]>;
+        required: true;
+    };
+    inputValue: StringConstructor;
+    placeholder: StringConstructor;
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    error: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    opened: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: PropType<Size>;
+    };
+    bordered: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allowClear: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allowCreate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allowSearch: {
+        type: BooleanConstructor;
+        default: (props: Data) => boolean;
+    };
+    maxTagCount: {
+        type: NumberConstructor;
+        default: number;
+    };
+    tagNowrap: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    retainInputValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {
+    inputRef: import('vue').ComputedRef<HTMLInputElement>;
+    handleFocus: (ev: FocusEvent) => void;
+    handleBlur: (ev: FocusEvent) => void;
+    render: () => VNode;
+}, {}, {}, {
+    focus(): void;
+    blur(): void;
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("focus" | "clear" | "blur" | "remove")[], "focus" | "clear" | "blur" | "remove", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    modelValue: {
+        type: PropType<SelectViewValue[]>;
+        required: true;
+    };
+    inputValue: StringConstructor;
+    placeholder: StringConstructor;
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    error: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    opened: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: PropType<Size>;
+    };
+    bordered: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allowClear: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allowCreate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allowSearch: {
+        type: BooleanConstructor;
+        default: (props: Data) => boolean;
+    };
+    maxTagCount: {
+        type: NumberConstructor;
+        default: number;
+    };
+    tagNowrap: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    retainInputValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onFocus?: ((...args: any[]) => any) | undefined;
+    onBlur?: ((...args: any[]) => any) | undefined;
+    onClear?: ((...args: any[]) => any) | undefined;
+    onRemove?: ((...args: any[]) => any) | undefined;
+}>, {
+    error: boolean;
+    disabled: boolean;
+    loading: boolean;
+    multiple: boolean;
+    opened: boolean;
+    allowClear: boolean;
+    bordered: boolean;
+    maxTagCount: number;
+    retainInputValue: boolean;
+    tagNowrap: boolean;
+    allowCreate: boolean;
+    allowSearch: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/_components/transition/expand-transition.vue.d.ts

@@ -0,0 +1,9 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    onBeforeEnter(el: Element): void;
+    onEnter(el: Element): void;
+    onAfterEnter(el: Element): void;
+    onBeforeLeave(el: Element): void;
+    onLeave(el: Element): void;
+    onAfterLeave(el: Element): void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;