@opentiny/vue-renderless 3.13.2 → 3.14.1

package/types/area.type.d.ts

@@ -1,2 +1,135 @@
+import { ExtractPropTypes } from 'vue';
+import { ISharedRenderlessParamUtils } from './shared.type.js';
 
-export { }
+declare const areaProps: {
+    modelValue: {};
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    size: StringConstructor;
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    props: {
+        type: ObjectConstructor;
+        default: () => {
+            label: string;
+            value: string;
+        };
+    };
+    fetchJcr: {
+        type: FunctionConstructor;
+    };
+    fetchRegion: {
+        type: FunctionConstructor;
+    };
+    fetchRep: {
+        type: FunctionConstructor;
+    };
+    fetchOffice: {
+        type: FunctionConstructor;
+    };
+    popperClass: StringConstructor;
+    popperAppendToBody: {
+        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;
+};
+
+/**
+ * Copyright (c) 2022 - present TinyVue Authors.
+ * Copyright (c) 2022 - present Huawei Cloud Computing Technologies Co., Ltd.
+ *
+ * Use of this source code is governed by an MIT-style license.
+ *
+ * THE OPEN SOURCE SOFTWARE IN THIS PRODUCT IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL,
+ * BUT WITHOUT ANY WARRANTY, WITHOUT EVEN THE IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS FOR
+ * A PARTICULAR PURPOSE. SEE THE APPLICABLE LICENSES FOR MORE DETAILS.
+ *
+ */
+declare const fetchDefaultData: ({ emit, fetchArea, nextTick, props, vm, state }: {
+    emit: any;
+    fetchArea: any;
+    nextTick: any;
+    props: any;
+    vm: any;
+    state: any;
+}) => () => void;
+declare const getRegion: ({ emit, fetchArea, nextTick, props, vm, state }: {
+    emit: any;
+    fetchArea: any;
+    nextTick: any;
+    props: any;
+    vm: any;
+    state: any;
+}) => (value: any) => void;
+declare const getRep: ({ emit, fetchArea, nextTick, props, vm, state }: {
+    emit: any;
+    fetchArea: any;
+    nextTick: any;
+    props: any;
+    vm: any;
+    state: any;
+}) => (value: any) => void;
+declare const getOffice: ({ emit, fetchArea, nextTick, props, vm, state }: {
+    emit: any;
+    fetchArea: any;
+    nextTick: any;
+    props: any;
+    vm: any;
+    state: any;
+}) => (value: any) => void;
+declare const changeOffice: ({ emit, state }: {
+    emit: any;
+    state: any;
+}) => (value: any) => void;
+declare const beforeMount: ({ api, props }: {
+    api: any;
+    props: any;
+}) => () => void;
+
+interface LabeValue {
+    label: string;
+    value: string;
+}
+interface IAreaState {
+    jcr: string;
+    region: string;
+    rep: string;
+    office: string;
+    jcrData: LabeValue[];
+    regionData: LabeValue[];
+    repData: LabeValue[];
+    officeData: LabeValue[];
+}
+interface IAreaRenderlessParams {
+    emit: ISharedRenderlessParamUtils['emit'];
+    fetchArea: (args: {
+        label: string;
+        parent: string;
+    }) => Promise<LabeValue[]>;
+    nextTick: ISharedRenderlessParamUtils['nextTick'];
+    props: IAreaProps;
+    refs: ISharedRenderlessParamUtils['refs'];
+    state: IAreaState;
+}
+type IAreaProps = ExtractPropTypes<typeof areaProps>;
+interface IAreaApi {
+    state: IAreaState;
+    changeOffice: ReturnType<typeof changeOffice>;
+    beforeMount: ReturnType<typeof beforeMount>;
+    getRep: ReturnType<typeof getRep>;
+    getRegion: ReturnType<typeof getRegion>;
+    getOffice: ReturnType<typeof getOffice>;
+    fetchDefaultData: ReturnType<typeof fetchDefaultData>;
+}
+
+export { IAreaApi, IAreaProps, IAreaRenderlessParams, IAreaState, LabeValue };

package/types/async-flowchart.type.d.ts

@@ -0,0 +1,72 @@
+import { ExtractPropTypes } from 'vue';
+import { ISharedRenderlessParamHooks, ISharedRenderlessParamUtils } from './shared.type.js';
+
+declare const asyncFlowchartProps: {
+    fetch: {
+        type: FunctionConstructor;
+        required: boolean;
+    };
+    tiny_mode: StringConstructor;
+    tiny_mode_root: BooleanConstructor;
+    tiny_template: (FunctionConstructor | ObjectConstructor)[];
+    tiny_renderless: FunctionConstructor;
+    tiny_theme: StringConstructor;
+    tiny_chart_theme: ObjectConstructor;
+};
+
+/**
+ * Copyright (c) 2022 - present TinyVue Authors.
+ * Copyright (c) 2022 - present Huawei Cloud Computing Technologies Co., Ltd.
+ *
+ * Use of this source code is governed by an MIT-style license.
+ *
+ * THE OPEN SOURCE SOFTWARE IN THIS PRODUCT IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL,
+ * BUT WITHOUT ANY WARRANTY, WITHOUT EVEN THE IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS FOR
+ * A PARTICULAR PURPOSE. SEE THE APPLICABLE LICENSES FOR MORE DETAILS.
+ *
+ */
+declare const index: any;
+
+declare const observeContainerSize: ({ nextTick, vm, state }: {
+    nextTick: ISharedRenderlessParamHooks['nextTick'];
+    vm: ISharedRenderlessParamUtils['vm'];
+    state: IAsyncFlowchartState;
+}) => () => void;
+declare const unobserveContainerSize: (state: IAsyncFlowchartState) => () => void;
+declare const fetchData: ({ Loading, props, state, vm, markRaw, api, nextTick }: {
+    Loading: any;
+    props: IAsyncFlowchartProps;
+    state: IAsyncFlowchartState;
+    vm: ISharedRenderlessParamUtils['vm'];
+    markRaw: ISharedRenderlessParamHooks['markRaw'];
+    api: IAsyncFlowchartApi;
+    nextTick: ISharedRenderlessParamHooks['nextTick'];
+}) => () => void;
+declare const handleClickNode: (emit: ISharedRenderlessParamUtils['emit']) => (afterNode: any, e: any) => void;
+declare const handleClickLink: (emit: ISharedRenderlessParamUtils['emit']) => (afterLink: any, e: any) => void;
+declare const handleClickBlank: (emit: ISharedRenderlessParamUtils['emit']) => (param: any, e: any) => void;
+declare const handleClickGroup: (emit: ISharedRenderlessParamUtils['emit']) => (afterGroup: any, e: any) => void;
+declare const refresh: (api: IAsyncFlowchartApi) => () => void;
+
+interface IAsyncFlowchartState {
+    loading: boolean;
+    data: null;
+    config: null | {
+        nodeWrapperSize: number;
+    };
+    temporary?: typeof index;
+}
+type IAsyncFlowchartProps = ExtractPropTypes<typeof asyncFlowchartProps>;
+interface IAsyncFlowchartApi {
+    state: IAsyncFlowchartState;
+    observeContainerSize: ReturnType<typeof observeContainerSize>;
+    unobserveContainerSize: ReturnType<typeof unobserveContainerSize>;
+    handleClickNode: ReturnType<typeof handleClickNode>;
+    handleClickLink: ReturnType<typeof handleClickLink>;
+    handleClickBlank: ReturnType<typeof handleClickBlank>;
+    handleClickGroup: ReturnType<typeof handleClickGroup>;
+    fetchData: ReturnType<typeof fetchData>;
+    refresh: ReturnType<typeof refresh>;
+}
+
+export { IAsyncFlowchartApi, IAsyncFlowchartProps, IAsyncFlowchartState };

package/types/autocomplete.type.d.ts

@@ -1,2 +1,200 @@
+import * as vue from 'vue';
+import { Ref, ComputedRef, ExtractPropTypes } from 'vue';
+import { ISharedRenderlessFunctionParams, ISharedRenderlessParamUtils } from './shared.type.js';
 
-export { }
+declare const autoCompleteProps: {
+    _constants: {
+        type: ObjectConstructor;
+        default: () => {
+            WARP_CLS: string;
+            ITEM_CLS: string;
+        };
+    };
+    autofocus: BooleanConstructor;
+    clearable: {
+        type: BooleanConstructor;
+        default: () => boolean;
+    };
+    customItem: StringConstructor;
+    debounce: {
+        type: NumberConstructor;
+        default: () => number;
+    };
+    disabled: BooleanConstructor;
+    fetchSuggestions: FunctionConstructor;
+    hideLoading: BooleanConstructor;
+    highlightFirstItem: {
+        type: BooleanConstructor;
+        default: () => boolean;
+    };
+    label: StringConstructor;
+    maxlength: NumberConstructor;
+    minlength: NumberConstructor;
+    modelValue: StringConstructor;
+    name: StringConstructor;
+    placeholder: StringConstructor;
+    placement: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    popperAppendToBody: {
+        type: BooleanConstructor;
+        default: () => boolean;
+    };
+    popperClass: StringConstructor;
+    popperOptions: ObjectConstructor;
+    prefixIcon: (StringConstructor | ObjectConstructor)[];
+    selectWhenUnmatched: {
+        type: BooleanConstructor;
+        default: () => boolean;
+    };
+    size: StringConstructor;
+    suffixIcon: (StringConstructor | ObjectConstructor)[];
+    triggerOnFocus: {
+        type: BooleanConstructor;
+        default: () => boolean;
+    };
+    valueKey: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    displayOnly: {
+        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;
+};
+
+declare const initSuggestionState: ({ reactive, parent, showPopper, popperElm, referenceElm }: {
+    reactive: ISharedRenderlessFunctionParams<null>['reactive'];
+    parent: IAutoCompleteRenderlessParamUtils['parent'];
+    showPopper: Ref<boolean>;
+    popperElm: Ref<HTMLElement>;
+    referenceElm: Ref<HTMLElement>;
+}) => {
+    parent: {
+        [x: string]: any;
+        $attrs: Record<string, any>;
+        $listeners: Record<string, Function>;
+        $children: any[];
+        $constants: {
+            WARP_CLS: string;
+            ITEM_CLS: string;
+        };
+        $el: HTMLElement;
+        $mode: "pc" | "mobile-first" | "mobile";
+        $nextTick: typeof vue.nextTick;
+        $emit: (...args: any[]) => void;
+        $off: (eventname?: string | undefined, callback?: Function | undefined) => void;
+        $on: (eventname: string, callback: Function) => void;
+        $once: (eventname: string, callback: Function) => void;
+        $options: {
+            componentName: string | undefined;
+        };
+        $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
+        $refs: Record<string, any>;
+        $slots: Record<string, Function>;
+        $scopedSlots: Record<string, Function>;
+        $set: (target: any, propertyName: any, value: any) => void;
+        $renderless: Function;
+        $template: any;
+    };
+    dropdownWidth: string;
+    showPopper: boolean;
+    popperElm: HTMLElement;
+    referenceElm: HTMLElement;
+};
+
+/**
+ * Copyright (c) 2022 - present TinyVue Authors.
+ * Copyright (c) 2022 - present Huawei Cloud Computing Technologies Co., Ltd.
+ *
+ * Use of this source code is governed by an MIT-style license.
+ *
+ * THE OPEN SOURCE SOFTWARE IN THIS PRODUCT IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL,
+ * BUT WITHOUT ANY WARRANTY, WITHOUT EVEN THE IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS FOR
+ * A PARTICULAR PURPOSE. SEE THE APPLICABLE LICENSES FOR MORE DETAILS.
+ *
+ */
+
+declare const handleChange: ({ api, emit, state, props }: {
+    api: IAutoCompleteApi;
+    emit: IAutoCompleteRenderlessParamUtils['emit'];
+    state: IAutoCompleteState;
+    props: IAutoCompleteProps;
+}) => (value: any) => void;
+declare const handleFocus: ({ api, emit, props, state }: {
+    api: IAutoCompleteApi;
+    emit: IAutoCompleteRenderlessParamUtils['emit'];
+    state: IAutoCompleteState;
+    props: IAutoCompleteProps;
+}) => (event: any) => void;
+declare const handleBlur: ({ emit, state }: {
+    emit: IAutoCompleteRenderlessParamUtils['emit'];
+    state: IAutoCompleteState;
+}) => (event: any) => void;
+declare const handleClear: ({ emit, state }: {
+    emit: IAutoCompleteRenderlessParamUtils['emit'];
+    state: IAutoCompleteState;
+}) => () => void;
+declare const close: (state: IAutoCompleteState) => () => void;
+declare const handleKeyEnter: ({ api, emit, nextTick, props, state }: {
+    api: IAutoCompleteApi;
+    emit: IAutoCompleteRenderlessParamUtils['emit'];
+    nextTick: IAutoCompleteRenderlessParamUtils['nextTick'];
+    props: IAutoCompleteProps;
+    state: IAutoCompleteState;
+}) => (event: any) => void;
+declare const select: ({ emit, nextTick, props, state }: {
+    emit: IAutoCompleteRenderlessParamUtils['emit'];
+    nextTick: IAutoCompleteRenderlessParamUtils['nextTick'];
+    props: IAutoCompleteProps;
+    state: IAutoCompleteState;
+}) => (item: any) => void;
+declare const highlight: ({ constants, vm, state }: {
+    constants: IAutoCompleteConstants;
+    state: IAutoCompleteState;
+}) => (index: any) => void;
+declare const watchVisible: ({ suggestionState, vm }: {
+    suggestionState: IAutoCompleteApi['suggestionState'];
+}) => (val: any) => void;
+declare const mounted: ({ vm, state, suggestionState }: {
+    state: IAutoCompleteState;
+    suggestionState: IAutoCompleteApi['suggestionState'];
+}) => () => void;
+
+interface IAutoCompleteState {
+    activated: boolean;
+    suggestions: unknown[];
+    loading: boolean;
+    highlightedIndex: number;
+    suggestionDisabled: boolean;
+    id: string;
+    suggestionVisible: ComputedRef<boolean>;
+}
+type IAutoCompleteProps = ExtractPropTypes<typeof autoCompleteProps>;
+interface IAutoCompleteApi {
+    state: IAutoCompleteState;
+    doDestroy: (forceDestroy?: boolean | undefined) => void;
+    suggestionState: ReturnType<typeof initSuggestionState>;
+    close: ReturnType<typeof close>;
+    handleBlur: ReturnType<typeof handleBlur>;
+    mounted: ReturnType<typeof mounted>;
+    highlight: ReturnType<typeof highlight>;
+    handleClear: ReturnType<typeof handleClear>;
+    select: ReturnType<typeof select>;
+    watchVisible: ReturnType<typeof watchVisible>;
+    handleChange: ReturnType<typeof handleChange>;
+    handleFocus: ReturnType<typeof handleFocus>;
+    handleKeyEnter: ReturnType<typeof handleKeyEnter>;
+    debouncedGetData: Function;
+}
+type IAutoCompleteConstants = ReturnType<typeof autoCompleteProps._constants.default>;
+type IAutoCompleteRenderlessParamUtils = ISharedRenderlessParamUtils<IAutoCompleteConstants>;
+
+export { IAutoCompleteApi, IAutoCompleteConstants, IAutoCompleteProps, IAutoCompleteRenderlessParamUtils, IAutoCompleteState };

package/types/badge.type.d.ts

@@ -1,4 +1,4 @@
-import { ExtractPropTypes } from 'vue';
+import { StyleValue, ExtractPropTypes } from 'vue';
 import { ISharedRenderlessFunctionParams, ISharedRenderlessParamUtils } from './shared.type.js';
 
 declare const badgeProps: {
@@ -59,6 +59,7 @@ declare const badgeProps: {
 
 declare const computedContent: ({ props, state }: Pick<IBadgeRenderlessParams, 'props' | 'state'>) => () => IBadgeContent;
 declare const computedValueRef: ({ props }: Pick<IBadgeRenderlessParams, 'props'>) => () => number | undefined;
+declare const computedTransform: ({ designConfig, props }: Pick<IBadgeRenderlessParams, 'designConfig' | 'props'>) => () => StyleValue;
 
 type IBadgeContent = string | number | undefined;
 interface IBadgeState {
@@ -76,6 +77,7 @@ interface IBadgeApi {
     state: IBadgeState;
     computedValueRef: ReturnType<typeof computedValueRef>;
     computedContent: ReturnType<typeof computedContent>;
+    computedTransform: ReturnType<typeof computedTransform>;
 }
 type IBadgeRenderlessParamUtils = ISharedRenderlessParamUtils<never>;
 

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

@@ -7,6 +7,7 @@ declare const breadcrumbItemProps: {
         type: BooleanConstructor;
         default: boolean;
     };
+    size: StringConstructor;
     option: {
         type: ObjectConstructor;
         default: () => {};
@@ -24,6 +25,7 @@ type IBreadcrumbItemRenderlessParams = ISharedRenderlessFunctionParams<never> &
     props: IBreadcrumbItemProps;
 };
 interface IBreadcrumbItemApi {
+    state: string | undefined;
     linkClick: (event: MouseEvent) => void;
 }
 type IBreadcrumbItemRenderlessParamUtils = ISharedRenderlessParamUtils<never>;

package/types/breadcrumb.type.d.ts

@@ -26,6 +26,7 @@ declare const breadcrumbProps: {
         type: StringConstructor;
         default: string;
     };
+    size: StringConstructor;
     options: {
         type: ArrayConstructor;
         default: () => never[];
@@ -41,6 +42,7 @@ declare const breadcrumbProps: {
 interface IBreadcrumbState {
     breadcrumbEmitter: object;
     currentBreadcrumbItem: object;
+    size: string | undefined;
 }
 type IBreadcrumbProps = ExtractPropTypes<typeof breadcrumbProps>;
 type IBreadcrumbConstants = typeof $constants;

package/types/button-group.type.d.ts

@@ -59,9 +59,9 @@ interface IButtonGroupItemClass {
     plain?: boolean;
 }
 interface IButtonGroupNode {
-    text: string;
-    value: string;
-    disabled: boolean;
+    text?: string;
+    value?: string;
+    disabled?: boolean;
     [otherKey: string]: any;
 }
 interface IButtonGroupState {

package/types/button.type.d.ts

@@ -26,6 +26,10 @@ declare const buttonProps: {
         type: StringConstructor;
         default: string;
     };
+    href: {
+        type: StringConstructor;
+        default: string;
+    };
     size: {
         type: StringConstructor;
         default: string;

package/types/cascader-menu.type.d.ts

@@ -1,5 +1,5 @@
 import { ISharedRenderlessFunctionParams, ISharedRenderlessParamUtils } from './shared.type.js';
-import { ICascaderPanelNode, ICascaderPanelApi } from './cascader-panel.type.js';
+import { I as ICascaderPanelNode, a as ICascaderPanelApi } from './cascader-panel.type-2bd03be3.js';
 import 'vue';
 
 /**
@@ -15,11 +15,10 @@ import 'vue';
  */
 
 declare const handleExpand: (state: ICascaderMenuState) => (e: MouseEvent) => HTMLElement;
-declare const handleMouseMove: ({ api, parent, refs, state, svg }: Pick<ICascaderMenuRenderlessParams, "state" | "api" | "parent"> & {
+declare const handleMouseMove: ({ api, parent, vm, state, svg }: Pick<ICascaderMenuRenderlessParams, "state" | "api" | "parent" | "vm"> & {
     svg: string;
-    refs: ICascaderMenuRenderlessParams['vm']['$refs'];
 }) => (e: MouseEvent) => void;
-declare const clearHoverZone: (refs: ICascaderMenuRenderlessParamUtils['vm']['$refs']) => () => void;
+declare const clearHoverZone: ({ vm }: Pick<ICascaderMenuRenderlessParams, 'vm'>) => () => void;
 
 interface ICascaderMenuProps {
     nodes: ICascaderPanelNode[];

package/types/cascader-node.type.d.ts

@@ -1,6 +1,6 @@
-import { ICascaderPanelNode, ICascaderPanelConfig, ICascaderPanelNodeValue, ICascaderPanelNodePropValue, ICascaderPanelApi } from './cascader-panel.type.js';
+import { VNode } from 'vue';
+import { I as ICascaderPanelNode, b as ICascaderPanelConfig, c as ICascaderPanelNodeValue, d as ICascaderPanelNodePropValue, a as ICascaderPanelApi } from './cascader-panel.type-2bd03be3.js';
 import { ISharedRenderlessFunctionParams } from './shared.type.js';
-import 'vue';
 
 /**
  * Copyright (c) 2022 - present TinyVue Authors.
@@ -19,6 +19,7 @@ declare const handleExpand: ({ api, parent, props, state }: Pick<ICascaderNodeRe
 declare const handleCheckChange: ({ api, parent, dispatch, state }: Pick<ICascaderNodeRenderlessParams, 'api' | 'parent' | 'dispatch' | 'state'>) => () => void;
 declare const handleMultiCheckChange: ({ parent, props }: Pick<ICascaderNodeRenderlessParams, 'parent' | 'props'>) => (checked: boolean) => void;
 declare const isInPath: (props: ICascaderNodeRenderlessParams['props']) => (pathNodes: ICascaderPanelNode[]) => boolean;
+declare const handleNodeClick: ({ state, api }: Pick<ICascaderNodeRenderlessParams, 'api' | 'state'>) => () => void;
 
 interface ICascaderNodeProps {
     node: ICascaderPanelNode;
@@ -33,6 +34,7 @@ interface ICascaderNodeState {
     inActivePath: boolean;
     inCheckedPath: boolean;
     value: ICascaderPanelNodePropValue;
+    nodeLabel: string | VNode;
 }
 interface ICascaderNodeApi {
     state: ICascaderNodeState;
@@ -41,6 +43,7 @@ interface ICascaderNodeApi {
     comptCheckPath: ReturnType<typeof comptCheckPath>;
     handleCheckChange: ReturnType<typeof handleCheckChange>;
     handleMultiCheckChange: ReturnType<typeof handleMultiCheckChange>;
+    handleNodeClick: ReturnType<typeof handleNodeClick>;
 }
 type ICascaderNodeRenderlessParams = ISharedRenderlessFunctionParams<never> & {
     state: ICascaderNodeState;