@opentiny/vue-renderless 3.12.1 → 3.13.1

package/types/dropdown.type.d.ts

@@ -70,6 +70,7 @@ declare const dropdownProps: {
         type: BooleanConstructor;
         default: boolean;
     };
+    suffixIcon: ObjectConstructor;
     tiny_mode: StringConstructor;
     tiny_mode_root: BooleanConstructor;
     tiny_template: (FunctionConstructor | ObjectConstructor)[];

package/types/input.type.d.ts

@@ -63,6 +63,10 @@ declare const inputProps: {
         type: StringConstructor;
         default: string;
     };
+    memorySpace: {
+        type: NumberConstructor;
+        default: number;
+    };
     vertical: {
         type: BooleanConstructor;
         default: boolean;
@@ -114,7 +118,7 @@ declare const inputProps: {
         type: BooleanConstructor;
         default: boolean;
     };
-    mobileTips: StringConstructor;
+    tips: StringConstructor;
     counter: {
         type: BooleanConstructor;
         default: boolean;
@@ -171,6 +175,13 @@ declare const inputProps: {
         type: BooleanConstructor;
         default: boolean;
     };
+    textAlign: {
+        type: StringConstructor;
+        default: string;
+    };
+    width: {
+        type: PropType<string | number | null>;
+    };
     tiny_mode: StringConstructor;
     tiny_mode_root: BooleanConstructor;
     tiny_template: (FunctionConstructor | ObjectConstructor)[];
@@ -209,6 +220,11 @@ declare const _default: ({ api, props, reactive, toRefs }: {
  *
  */
 
+declare const inputStyle: ({ props }: {
+    props: any;
+}) => () => {
+    textAlign: any;
+};
 declare const calculateNodeStyling: () => (targetElement: HTMLElement) => {
     contextStyle: string;
     paddingSize: number;
@@ -221,7 +237,7 @@ declare const calcTextareaHeight: ({ api, hiddenTextarea, props, state }: Pick<I
     minHeight?: string | undefined;
     height?: string | undefined;
 };
-declare const getInput: (refs: IInputRenderlessParams['refs']) => () => HTMLTextAreaElement | HTMLInputElement;
+declare const getInput: (vm: IInputRenderlessParamUtils['vm']) => () => HTMLTextAreaElement | HTMLInputElement;
 declare const focus: (api: IInputApi) => () => void;
 declare const handleInput: ({ api, emit, nextTick, state }: Pick<IInputRenderlessParams, 'api' | 'emit' | 'nextTick' | 'state'>) => (event: Event) => void;
 declare const resizeTextarea: ({ api, parent, refs, state }: Pick<IInputRenderlessParams, 'api' | 'parent' | 'refs' | 'state'>) => () => void;
@@ -243,7 +259,8 @@ interface IInputState {
     passwordVisible: boolean;
     boxVisibility: boolean;
     textareaCalcStyle: object;
-    checkedLable: string;
+    checkedLabel: string;
+    width: string;
     sheetvalue: string | number | undefined;
     inputSize: ComputedRef<string>;
     showClear: ComputedRef<boolean>;
@@ -284,6 +301,7 @@ interface IInputApi extends Pick<IInputRenderlessParamUtils, 'dispatch'> {
     calcIconOffset: ReturnType<typeof calcIconOffset>;
     focus: ReturnType<typeof focus>;
     getDisplayedValue: ReturnType<typeof getDisplayedValue>;
+    inputStyle: ReturnType<typeof inputStyle>;
 }
 type IInputRenderlessParams = ISharedRenderlessFunctionParams<IInputConstants> & {
     state: IInputState;

package/types/label.type.d.ts

@@ -0,0 +1,81 @@
+import { ExtractPropTypes, ComputedRef } from 'vue';
+import { ISharedRenderlessFunctionParams, ISharedRenderlessParamUtils } from './shared.type.js';
+
+declare const labelProps: {
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    size: {
+        type: StringConstructor;
+        default: string;
+    };
+    type: {
+        type: StringConstructor;
+        default: string;
+    };
+    wholeline: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    position: {
+        type: StringConstructor;
+        default: string;
+    };
+    ellipsis: {
+        type: NumberConstructor;
+        default: number;
+    };
+    decimal: {
+        type: NumberConstructor;
+        default: number;
+    };
+    limit: {
+        type: NumberConstructor;
+        default: number;
+    };
+    isRequired: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    bold: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tiny_mode: StringConstructor;
+    tiny_mode_root: BooleanConstructor;
+    tiny_template: (FunctionConstructor | ObjectConstructor)[];
+    tiny_renderless: FunctionConstructor;
+    tiny_theme: StringConstructor;
+    tiny_chart_theme: ObjectConstructor;
+};
+
+type ILabelProps = ExtractPropTypes<typeof labelProps>;
+interface ILabelState {
+    label: ComputedRef<string>;
+    type: ComputedRef<string>;
+    color: ComputedRef<string>;
+    size: ComputedRef<string>;
+    labelStyle: ComputedRef<object>;
+    labelClass: ComputedRef<string>;
+    isRequired: ComputedRef<boolean>;
+}
+interface ILabelApi {
+    state: ILabelState;
+    handleClick: (event: MouseEvent) => void;
+    computeLabel: () => string;
+    computeLabelStyle: () => object;
+    computeLabelClass: () => [];
+}
+type ILabelRenderlessParams = ISharedRenderlessFunctionParams<never> & {
+    api: ILabelApi;
+    state: ILabelState;
+    props: ILabelProps;
+};
+type ILabelRenderlessParamUtils = ISharedRenderlessParamUtils<never>;
+
+export { ILabelApi, ILabelProps, ILabelRenderlessParamUtils, ILabelRenderlessParams, ILabelState };

package/types/numeric.type.d.ts

@@ -186,7 +186,7 @@ declare const handleFocus: ({ emit, state, props, api, refs }: Pick<INumericRend
 declare const focus: (refs: INumericRenderlessParams['refs']) => () => void;
 declare const setCurrentValue: ({ api, constants, dispatch, emit, props, state }: Pick<INumericRenderlessParams, 'api' | 'constants' | 'dispatch' | 'emit' | 'props' | 'state'>) => (newVal: number) => void;
 declare const handleInput: ({ state, api, emit, props }: Pick<INumericRenderlessParams, 'state' | 'api' | 'emit' | 'props'>) => (event: InputEvent) => void;
-declare const handleInputChange: ({ api }: Pick<INumericRenderlessParams, 'api'>) => (event: Event) => void;
+declare const handleInputChange: ({ api, state, props }: Pick<INumericRenderlessParams, 'api' | 'state' | 'props'>) => (event: Event) => void;
 declare const select: (refs: INumericRenderlessParams['refs']) => () => any;
 declare const mounted: ({ constants, parent, props, state }: Pick<INumericRenderlessParams, 'constants' | 'parent' | 'props' | 'state'>) => () => void;
 declare const unmounted: ({ parent, state }: Pick<INumericRenderlessParams, 'parent' | 'state'>) => () => void;

package/types/pager.type.d.ts

@@ -1,2 +1,160 @@
+import { PropType, ExtractPropTypes } from 'vue';
+import { ISharedRenderlessFunctionParams, ISharedRenderlessParamUtils } from './shared.type.js';
 
-export { }
+declare const pagerProps: {
+    accurateJumper: {
+        type: BooleanConstructor;
+        default: () => boolean;
+    };
+    appendToBody: {
+        type: BooleanConstructor;
+        default: () => boolean;
+    };
+    currentPage: {
+        type: NumberConstructor;
+        default: () => number;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: () => boolean;
+    };
+    hideOnSinglePage: BooleanConstructor;
+    isBeforePageChange: BooleanConstructor;
+    layout: StringConstructor;
+    mode: StringConstructor;
+    nextText: StringConstructor;
+    pageCount: NumberConstructor;
+    pageSize: {
+        type: NumberConstructor;
+        default: () => number;
+    };
+    pageSizes: {
+        type: PropType<number[]>;
+        default: () => number[];
+    };
+    pagerCount: {
+        type: NumberConstructor;
+        validator: (value: any) => boolean;
+        default: () => number;
+    };
+    popperAppendToBody: {
+        type: BooleanConstructor;
+        default: () => boolean;
+    };
+    showTotalLoading: {
+        type: BooleanConstructor;
+        default: () => boolean;
+    };
+    customTotal: {
+        type: (StringConstructor | BooleanConstructor)[];
+        default: () => boolean;
+    };
+    popperClass: StringConstructor;
+    prevText: StringConstructor;
+    total: NumberConstructor;
+    size: {
+        type: StringConstructor;
+        default: string;
+    };
+    align: {
+        type: StringConstructor;
+        validator: (value: any) => boolean;
+    };
+    tiny_mode: StringConstructor;
+    tiny_mode_root: BooleanConstructor;
+    tiny_template: (FunctionConstructor | ObjectConstructor)[];
+    tiny_renderless: FunctionConstructor;
+    tiny_theme: StringConstructor;
+    tiny_chart_theme: ObjectConstructor;
+};
+
+declare const computedShowPager: ({ props, state }: Pick<IPagerRenderlessParams, 'props' | 'state'>) => () => boolean;
+declare const computedInternalLayout: ({ props }: Pick<IPagerRenderlessParams, 'props'>) => () => string[];
+declare const computedTotalText: ({ props, t }: Pick<IPagerRenderlessParams, 'props' | 't'>) => () => string;
+declare const computedInternalPageCount: ({ props, state }: Pick<IPagerRenderlessParams, 'props' | 'state'>) => () => number | null;
+declare const handleJumperFocus: ({ state }: Pick<IPagerRenderlessParams, 'state'>) => (e: Event) => void;
+declare const watchInternalCurrentPage: ({ state, emit }: Pick<IPagerRenderlessParams, 'state' | 'emit'>) => (currentPage: number) => void;
+declare const watchPageSizes: ({ state, props }: Pick<IPagerRenderlessParams, 'props' | 'state'>) => (newVal: number[]) => void;
+declare const watchCurrentPage: ({ state, api }: Pick<IPagerRenderlessParams, 'api' | 'state'>) => (curPage: number) => void;
+declare const watchInternalPageCount: ({ state, api }: Pick<IPagerRenderlessParams, 'api' | 'state'>) => (pageCount: number | null) => void;
+declare const watchPageSize: ({ state }: Pick<IPagerRenderlessParams, 'state'>) => (pageSize: number) => void;
+declare const watchTotal: ({ state }: Pick<IPagerRenderlessParams, 'state'>) => (total: number | undefined) => void;
+declare const handleSizeChange: ({ props, state, api, emit, vm }: Pick<IPagerRenderlessParams, 'props' | 'state' | 'api' | 'emit' | 'vm'>) => (val: number) => void;
+declare const handleJumperInput: ({ state }: Pick<IPagerRenderlessParams, 'state'>) => (e: Event) => void;
+declare const handleJumperChange: ({ props, state, api }: Pick<IPagerRenderlessParams, 'props' | 'state' | 'api'>) => () => void;
+declare const handleJumperClick: ({ props, state, api }: Pick<IPagerRenderlessParams, 'props' | 'state' | 'api'>) => () => void;
+declare const isValueNumber: ({ state }: Pick<IPagerRenderlessParams, 'state'>) => () => boolean;
+declare const parseValueNumber: ({ state }: Pick<IPagerRenderlessParams, 'state'>) => () => void;
+declare const handleSizeShowPopover: ({ state, props }: Pick<IPagerRenderlessParams, 'props' | 'state'>) => () => void;
+declare const handleSizeHidePopover: ({ state }: Pick<IPagerRenderlessParams, 'state'>) => () => void;
+declare const canJumperGo: ({ props, state, vm }: Pick<IPagerRenderlessParams, 'props' | 'state' | 'vm'>) => () => boolean;
+declare const beforeSizeChangeHandler: ({ state, emit }: Pick<IPagerRenderlessParams, 'emit' | 'state'>) => (params: any) => void;
+declare const beforePagerChangeHandler: ({ state, emit }: Pick<IPagerRenderlessParams, 'emit' | 'state'>) => (params: any) => void;
+declare const copyEmit: ({ emit }: Pick<IPagerRenderlessParams, 'emit'>) => (...args: any[]) => void;
+declare const beforeChangeHandler: ({ state, api }: Pick<IPagerRenderlessParams, 'api' | 'state'>) => (val?: number) => boolean;
+declare const handleCurrentChange: ({ state, api }: Pick<IPagerRenderlessParams, 'api' | 'state'>) => (val: number) => void;
+declare const prev: ({ state, props, api, emit }: Pick<IPagerRenderlessParams, 'props' | 'state' | 'api' | 'emit'>) => () => void;
+declare const next: ({ props, state, api, emit }: Pick<IPagerRenderlessParams, 'props' | 'state' | 'api' | 'emit'>) => () => void;
+declare const buildBeforePageChangeParam: ({ state }: Pick<IPagerRenderlessParams, 'state'>) => (param: any) => any;
+declare const getValidCurrentPage: ({ state }: Pick<IPagerRenderlessParams, 'state'>) => (val: string | number) => any;
+declare const emitChange: ({ state, nextTick, emit }: Pick<IPagerRenderlessParams, 'emit' | 'state' | 'nextTick'>) => () => void;
+declare const setTotal: ({ state }: Pick<IPagerRenderlessParams, 'state'>) => (val: number) => void;
+
+type IPagerProps = ExtractPropTypes<typeof pagerProps>;
+interface IPagerState {
+    showPager: boolean;
+    showSizes: boolean;
+    internalCurrentPage: number;
+    internalPageSize: number;
+    lastEmittedPage: number;
+    userChangePageSize: boolean;
+    internalTotal: number | undefined;
+    jumperValue: string;
+    jumperBackup: string;
+    internalLayout: string[];
+    totalText: string;
+    internalPageCount: number | null;
+}
+interface IPagerApi {
+    state: IPagerState;
+    t: IPagerRenderlessParamUtils['t'];
+    computedShowPager: ReturnType<typeof computedShowPager>;
+    computedInternalLayout: ReturnType<typeof computedInternalLayout>;
+    computedTotalText: ReturnType<typeof computedTotalText>;
+    computedInternalPageCount: ReturnType<typeof computedInternalPageCount>;
+    handleJumperFocus: ReturnType<typeof handleJumperFocus>;
+    handleSizeChange: ReturnType<typeof handleSizeChange>;
+    handleJumperInput: ReturnType<typeof handleJumperInput>;
+    handleJumperChange: ReturnType<typeof handleJumperChange>;
+    handleJumperClick: ReturnType<typeof handleJumperClick>;
+    isValueNumber: ReturnType<typeof isValueNumber>;
+    parseValueNumber: ReturnType<typeof parseValueNumber>;
+    handleSizeShowPopover: ReturnType<typeof handleSizeShowPopover>;
+    handleSizeHidePopover: ReturnType<typeof handleSizeHidePopover>;
+    canJumperGo: ReturnType<typeof canJumperGo>;
+    beforeSizeChangeHandler: ReturnType<typeof beforeSizeChangeHandler>;
+    beforePagerChangeHandler: ReturnType<typeof beforePagerChangeHandler>;
+    copyEmit: ReturnType<typeof copyEmit>;
+    beforeChangeHandler: ReturnType<typeof beforeChangeHandler>;
+    handleCurrentChange: ReturnType<typeof handleCurrentChange>;
+    prev: ReturnType<typeof prev>;
+    next: ReturnType<typeof next>;
+    buildBeforePageChangeParam: ReturnType<typeof buildBeforePageChangeParam>;
+    getValidCurrentPage: ReturnType<typeof getValidCurrentPage>;
+    emitChange: ReturnType<typeof emitChange>;
+    setTotal: ReturnType<typeof setTotal>;
+    watchInternalCurrentPage: ReturnType<typeof watchInternalCurrentPage>;
+    watchPageSizes: ReturnType<typeof watchPageSizes>;
+    watchCurrentPage: ReturnType<typeof watchCurrentPage>;
+    watchInternalPageCount: ReturnType<typeof watchInternalPageCount>;
+    watchPageSize: ReturnType<typeof watchPageSize>;
+    watchTotal: ReturnType<typeof watchTotal>;
+}
+type IPagerRenderlessParams = ISharedRenderlessFunctionParams<never> & {
+    api: IPagerApi;
+    state: IPagerState;
+    props: IPagerProps;
+};
+type IPagerRenderlessParamUtils = ISharedRenderlessParamUtils<never>;
+
+export { IPagerApi, IPagerProps, IPagerRenderlessParamUtils, IPagerRenderlessParams, IPagerState };

package/types/slider.type.d.ts

@@ -148,6 +148,7 @@ interface ISliderState {
     leftBtnStyle: string;
     leftBtnPercent: number;
     leftBtnShow: true;
+    mouseOuterBtn: boolean;
     rightBtnStyle: string;
     rightBtnPercent: number;
     rightBtnShow: boolean;
@@ -156,6 +157,10 @@ interface ISliderState {
     tipValue: ComputedRef<string>;
     formDisabled: ComputedRef<boolean>;
     disabled: ComputedRef<boolean>;
+    /** 使用这个值作为插槽中输入的值，而不是直接用activeValue，来实现在输入时不会被max min属性计算而改变 */
+    slotValue: number;
+    /** 是否正在输入 */
+    isSlotTyping: boolean;
 }
 interface ISliderApi {
     state: ISliderState;
@@ -186,6 +191,9 @@ interface ISliderApi {
     getPoints: () => void;
     getLabels: () => void;
     inputValueChange: () => void;
+    handleSlotInputFocus: () => void;
+    handleSlotInputBlur: () => void;
+    handleSlotInput: (event: Event) => void;
 }
 type ISliderRenderlessParams = ISharedRenderlessFunctionParams<ISliderConstants> & {
     state: ISliderState;

package/types/tab-item.type.d.ts

@@ -9,7 +9,6 @@ declare const tabItemProps: {
         default: () => {};
     };
     title: StringConstructor;
-    labelContent: FunctionConstructor;
     name: StringConstructor;
     withClose: BooleanConstructor;
     disabled: BooleanConstructor;

package/types/tag.type.d.ts

@@ -23,6 +23,14 @@ declare const tagProps: {
     };
     beforeDelete: FunctionConstructor;
     value: (StringConstructor | NumberConstructor)[];
+    mini: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maxWidth: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: null;
+    };
     tiny_mode: StringConstructor;
     tiny_mode_root: BooleanConstructor;
     tiny_template: (FunctionConstructor | ObjectConstructor)[];
@@ -35,6 +43,10 @@ interface ITagState {
     type: string | undefined;
     show: boolean;
     selected: boolean;
+    text: string;
+    color: string;
+    mini: boolean;
+    maxWidth: string | number;
 }
 interface ITagApi {
     state: ITagState;