@hb-hellotech/hb-ui 0.0.1

package/dist/components/func-comp/hb_func_comp_tree/src/tree.vue.d.ts

@@ -0,0 +1,186 @@
+import { Key, TreeNodes, TreeOptions } from "./tree";
+declare const _sfc_main: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly data: {
+        readonly type: import("vue").PropType<TreeOptions[]>;
+        readonly required: true;
+    };
+    readonly modelValue: {
+        readonly type: ArrayConstructor;
+        readonly default: () => never[];
+    };
+    readonly labelKey: {
+        readonly type: StringConstructor;
+        readonly default: "label";
+    };
+    readonly keyKey: {
+        readonly type: StringConstructor;
+        readonly default: "key";
+    };
+    readonly childrenKey: {
+        readonly type: StringConstructor;
+        readonly default: "children";
+    };
+    readonly defaultExpandKeys: {
+        readonly type: import("vue").PropType<Key[]>;
+        readonly default: () => never[];
+    };
+    readonly multiple: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly remote: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly clickToSelect: {
+        readonly type: BooleanConstructor;
+    };
+}>, {
+    props: any;
+    bem: {
+        b: (block?: string | undefined) => string;
+        e: (element: string) => string;
+        m: (modifier: string) => string;
+        be: (block: string, element: string) => string;
+        em: (element: string, modifier: string) => string;
+        bem: (block: string, element: string, modifier: string) => string;
+        is: (name: string, state: string | boolean) => string;
+    };
+    afterFormatData: import("vue").Ref<{
+        [x: string]: unknown;
+        expanded?: boolean | undefined;
+        checked?: boolean | undefined;
+        indeterminate?: boolean | undefined;
+        disabled?: boolean | undefined;
+        loading?: boolean | undefined;
+        selected?: boolean | undefined;
+        leaf?: boolean | undefined;
+        parentKey?: Key | null | undefined;
+        level?: number | undefined;
+        originData?: {
+            [x: string]: unknown;
+            label?: Key | undefined;
+            key?: Key | undefined;
+            children?: any[] | undefined;
+        } | undefined;
+        label: Key;
+        key: Key;
+        children: {
+            [x: string]: unknown;
+            label?: Key | undefined;
+            key?: Key | undefined;
+            children?: any[] | undefined;
+        }[];
+    }[], TreeNodes[] | {
+        [x: string]: unknown;
+        expanded?: boolean | undefined;
+        checked?: boolean | undefined;
+        indeterminate?: boolean | undefined;
+        disabled?: boolean | undefined;
+        loading?: boolean | undefined;
+        selected?: boolean | undefined;
+        leaf?: boolean | undefined;
+        parentKey?: Key | null | undefined;
+        level?: number | undefined;
+        originData?: {
+            [x: string]: unknown;
+            label?: Key | undefined;
+            key?: Key | undefined;
+            children?: any[] | undefined;
+        } | undefined;
+        label: Key;
+        key: Key;
+        children: {
+            [x: string]: unknown;
+            label?: Key | undefined;
+            key?: Key | undefined;
+            children?: any[] | undefined;
+        }[];
+    }[]>;
+    expandedKeys: import("vue").Ref<Set<Key> & Omit<Set<Key>, keyof Set<any>>, Set<Key> | (Set<Key> & Omit<Set<Key>, keyof Set<any>>)>;
+    formatData: (data: TreeOptions[]) => TreeNodes[];
+    flatterTree: import("vue").ComputedRef<TreeNodes[]>;
+    toggleExpand: (key: Key) => void;
+    handleClick: () => void;
+    TreeNode: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        item: {
+            type: import("vue").PropType<TreeNodes>;
+            default(): {};
+        };
+        expandedKeys: {
+            type: import("vue").PropType<Set<string | number>>;
+        };
+    }>, {
+        props: any;
+        emits: (event: "toggleExpand", ...args: any[]) => void;
+        bem: {
+            b: (block?: string | undefined) => string;
+            e: (element: string) => string;
+            m: (modifier: string) => string;
+            be: (block: string, element: string) => string;
+            em: (element: string, modifier: string) => string;
+            bem: (block: string, element: string, modifier: string) => string;
+            is: (name: string, state: string | boolean) => string;
+        };
+        isExpanded: import("vue").ComputedRef<boolean>;
+        handleClick: () => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "toggleExpand"[], "toggleExpand", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        item: {
+            type: import("vue").PropType<TreeNodes>;
+            default(): {};
+        };
+        expandedKeys: {
+            type: import("vue").PropType<Set<string | number>>;
+        };
+    }>> & Readonly<{
+        onToggleExpand?: ((...args: any[]) => any) | undefined;
+    }>, {
+        item: TreeNodes;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly data: {
+        readonly type: import("vue").PropType<TreeOptions[]>;
+        readonly required: true;
+    };
+    readonly modelValue: {
+        readonly type: ArrayConstructor;
+        readonly default: () => never[];
+    };
+    readonly labelKey: {
+        readonly type: StringConstructor;
+        readonly default: "label";
+    };
+    readonly keyKey: {
+        readonly type: StringConstructor;
+        readonly default: "key";
+    };
+    readonly childrenKey: {
+        readonly type: StringConstructor;
+        readonly default: "children";
+    };
+    readonly defaultExpandKeys: {
+        readonly type: import("vue").PropType<Key[]>;
+        readonly default: () => never[];
+    };
+    readonly multiple: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly remote: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly clickToSelect: {
+        readonly type: BooleanConstructor;
+    };
+}>> & Readonly<{}>, {
+    readonly modelValue: unknown[];
+    readonly labelKey: string;
+    readonly keyKey: string;
+    readonly childrenKey: string;
+    readonly defaultExpandKeys: Key[];
+    readonly multiple: boolean;
+    readonly remote: boolean;
+    readonly clickToSelect: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _sfc_main;

package/dist/components/func-comp/hb_func_comp_tree/src/treeNode.vue.d.ts

@@ -0,0 +1,38 @@
+import { PropType } from "vue";
+import { TreeNodes } from "./tree";
+declare const _sfc_main: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    item: {
+        type: PropType<TreeNodes>;
+        default(): {};
+    };
+    expandedKeys: {
+        type: PropType<Set<string | number>>;
+    };
+}>, {
+    props: any;
+    emits: (event: "toggleExpand", ...args: any[]) => void;
+    bem: {
+        b: (block?: string | undefined) => string;
+        e: (element: string) => string;
+        m: (modifier: string) => string;
+        be: (block: string, element: string) => string;
+        em: (element: string, modifier: string) => string;
+        bem: (block: string, element: string, modifier: string) => string;
+        is: (name: string, state: string | boolean) => string;
+    };
+    isExpanded: import("vue").ComputedRef<boolean>;
+    handleClick: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "toggleExpand"[], "toggleExpand", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    item: {
+        type: PropType<TreeNodes>;
+        default(): {};
+    };
+    expandedKeys: {
+        type: PropType<Set<string | number>>;
+    };
+}>> & Readonly<{
+    onToggleExpand?: ((...args: any[]) => any) | undefined;
+}>, {
+    item: TreeNodes;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _sfc_main;

package/dist/components/func-comp/index.d.ts

@@ -0,0 +1,2 @@
+declare const HbFuncComponents: any;
+export default HbFuncComponents;

package/dist/components/hooks/useCalTableHeight.d.ts

@@ -0,0 +1,10 @@
+interface TableHeightOptions {
+    formRef?: any;
+    offsetBottom?: number;
+    minHeight?: number;
+}
+declare const useCalTableHeight: (options?: TableHeightOptions) => {
+    tableHeight: import("vue").Ref<number, number>;
+    calTableHeight: () => void;
+};
+export default useCalTableHeight;

package/dist/components/hooks/useCalTableWidth.d.ts

@@ -0,0 +1,5 @@
+import { type ComputedRef } from 'vue';
+declare const useCalTableWidth: (columns: ComputedRef<any[]> | any[]) => {
+    tableWidth: ComputedRef<number>;
+};
+export default useCalTableWidth;

package/dist/components/types/hb_form_item_filter_modal_type.d.ts

@@ -0,0 +1,37 @@
+import type { ExtractPropTypes, PropType } from 'vue';
+export interface LocalShowList_intf {
+    label?: string;
+    key: string;
+    isFixed?: boolean;
+    isActive?: boolean;
+    isLinked?: boolean;
+    labelLanguage?: string;
+    [key: string]: any;
+}
+export interface HbSfCmProps_intf {
+    subLabel?: string;
+    label?: string;
+    prop?: string;
+    showNumber?: number;
+    [key: string]: any;
+}
+export declare const HbSfCmProps: {
+    readonly list: {
+        readonly type: PropType<HbSfCmProps_intf[]>;
+        readonly default: () => never[];
+        readonly required: true;
+    };
+    readonly afterChange: {
+        readonly type: PropType<(val: any) => void>;
+        readonly default: () => void;
+    };
+    readonly title: {
+        readonly type: PropType<string>;
+        readonly default: "自定义查询条件";
+    };
+    readonly showNumber: {
+        readonly type: PropType<number>;
+        readonly default: 40;
+    };
+};
+export type HbSfCmType = ExtractPropTypes<typeof HbSfCmProps>;

package/dist/components/types/hb_form_select_filter_type.d.ts

@@ -0,0 +1,27 @@
+export interface SelectorOption_Intf {
+    label: string;
+    value: string | number;
+    description?: string;
+}
+export interface SelectorProps_Intf {
+    title?: string;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    width?: number;
+    options?: SelectorOption_Intf[];
+    multiple?: boolean;
+    prefix?: string;
+    value?: string | string[];
+    remoteSearch?: boolean;
+    searchValue?: string;
+    maxTagCount?: number;
+    tagTextLength?: number;
+}
+export interface Emits_Intf {
+    'update:value': [value: string | string[]];
+    'update:searchValue': [searchValue: string];
+    change: [value: string | string[], selectedOptions: SelectorOption_Intf[]];
+    confirm: [value: string | string[], selectedOptions: SelectorOption_Intf[]];
+    cancel: [];
+    search: [keyword: string];
+}

package/dist/components/types/hb_form_select_modal_type.d.ts

@@ -0,0 +1,33 @@
+import type { ExtractPropTypes } from 'vue';
+export declare const HbFormSelectModalprops: {
+    readonly modelTitle: {
+        readonly type: StringConstructor;
+        readonly default: "搜索弹窗";
+    };
+    readonly modalWidth: {
+        readonly type: NumberConstructor;
+        readonly default: 800;
+    };
+    readonly tableHeight: {
+        readonly type: NumberConstructor;
+        readonly default: 500;
+    };
+    readonly tableColumn: {
+        readonly type: ArrayConstructor;
+        readonly default: () => never[];
+        readonly required: true;
+    };
+    readonly tableData: {
+        readonly type: ArrayConstructor;
+        readonly default: () => never[];
+    };
+    readonly tableKey: {
+        readonly type: StringConstructor;
+        readonly default: "id";
+    };
+    readonly labelKey: {
+        readonly type: StringConstructor;
+        readonly default: "label";
+    };
+};
+export type HbFormSelectModalpropsType = ExtractPropTypes<typeof HbFormSelectModalprops>;

package/dist/components/types/hb_list_btns_act_type.d.ts

@@ -0,0 +1,21 @@
+import type { ExtractPropTypes, PropType } from 'vue';
+import type { LocalShowList_intf } from '../../components/types/hb_form_item_filter_modal_type';
+export declare const HbListBtnsProps: {
+    readonly formItems: {
+        readonly type: PropType<LocalShowList_intf[]>;
+        readonly default: () => never[];
+    };
+    readonly isShowSelfFilter: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly needReload: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly needOpenOrClose: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+};
+export type HbListBtnsPropsType = ExtractPropTypes<typeof HbListBtnsProps>;

package/dist/components/types/hb_list_form_type.d.ts

@@ -0,0 +1,70 @@
+import type { ExtractPropTypes, PropType } from 'vue';
+import type { FormProps, FormItemProps } from 'ant-design-vue';
+export type SelfType = 'slot' | 'mixin';
+export type FormType = 'input' | 'select' | 'checkbox' | 'date-picker' | 'input-number' | 'radio' | 'switch';
+export type Type = FormType | SelfType;
+export interface BaseFormItem extends Partial<FormItemProps> {
+    type: Type;
+    prop: string;
+    label?: string;
+    width?: string;
+    align?: string;
+    tooltip?: boolean;
+    isFixed?: boolean;
+    left?: Partial<HbFormItems>;
+    right?: Partial<HbFormItems>;
+    isUnNeedBorder?: boolean;
+    [key: string]: any;
+}
+type FormItemWithConditionalOptions<T extends Type> = T extends 'select' ? BaseFormItem & {
+    options: Record<string, any>;
+} : BaseFormItem & {
+    options?: Record<string, any>;
+};
+export type HbFormItems = FormItemWithConditionalOptions<SelfType | FormType>;
+export declare const HbFormProps: {
+    readonly items: {
+        readonly type: PropType<HbFormItems[]>;
+        readonly required: true;
+    };
+    readonly formData: {
+        readonly type: PropType<Record<string, any>>;
+        readonly required: true;
+    };
+    readonly layoutConfig: {
+        readonly type: PropType<{
+            row: Record<string, any>;
+            col: Record<string, any>;
+        }>;
+        readonly default: {
+            readonly row: {
+                readonly gutter: 20;
+            };
+            readonly col: {
+                readonly xs: 24;
+                readonly sm: 12;
+                readonly md: 8;
+                readonly lg: 6;
+                readonly xl: 6;
+            };
+        };
+    };
+    readonly needFooter: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly isFormExpanded: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly needFilter: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly calTableHeight: {
+        readonly type: PropType<() => void>;
+        readonly default: () => void;
+    };
+};
+export type HbFormPropsType = ExtractPropTypes<typeof HbFormProps> & FormProps;
+export {};

package/dist/components/types/hb_list_page_act_type.d.ts

@@ -0,0 +1,25 @@
+import type { ExtractPropTypes, PropType } from 'vue';
+import type { LocalShowList_intf } from '../../components/types/hb_form_item_filter_modal_type';
+export interface Breadcrumbs_intf {
+    label: string;
+    value: string;
+}
+export declare const HbListPageActProps: {
+    readonly formItems: {
+        readonly type: PropType<LocalShowList_intf[]>;
+        readonly default: () => never[];
+    };
+    readonly isShowSelfFilter: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly isShowOpenClose: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly isShowFullScreen: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+};
+export type HbListPageActType = ExtractPropTypes<typeof HbListPageActProps>;

package/dist/components/types/hb_list_page_container_type.d.ts

@@ -0,0 +1,18 @@
+import type { ExtractPropTypes } from 'vue';
+export declare const ListPageContainerProps: {
+    readonly tableHeight: {
+        readonly type: NumberConstructor;
+        readonly default: 400;
+    };
+    readonly tabelData: {
+        readonly type: ArrayConstructor;
+        readonly default: () => never[];
+    };
+    readonly offsetBottom: {
+        readonly type: NumberConstructor;
+    };
+    readonly minHeight: {
+        readonly type: NumberConstructor;
+    };
+};
+export type HbLibListPageContainerProps = ExtractPropTypes<typeof ListPageContainerProps>;

package/dist/components/types/hb_list_table_act_type.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 操作项接口定义
+ */
+export interface ActionItem {
+    key: string;
+    label: string;
+    condition?: boolean;
+    type?: 'main' | 'more';
+    handler: Function;
+    needConfirm?: boolean;
+    confirmTitle?: string;
+    confirmType?: 'popconfirm' | 'modal';
+    confirmContent?: string;
+    permissionsTag?: string;
+}
+/**
+ * 组件属性接口定义
+ */
+export interface Props {
+    actions: ActionItem[];
+    record: any;
+    buttonDisplaysQuantity?: number;
+}

package/dist/components/types/hb_list_table_colums_set_type.d.ts

@@ -0,0 +1,7 @@
+export interface DragItem_Intf {
+    label: string;
+    value: string;
+    fixed?: string | boolean;
+    checked: string | boolean;
+    [key: string]: unknown;
+}

package/dist/components/types/hb_list_table_type.d.ts

@@ -0,0 +1,34 @@
+import type { ExtractPropTypes, PropType } from 'vue';
+export interface ColumnType {
+    title: string;
+    dataIndex: string;
+    key: string;
+    width?: string | number;
+    align?: string;
+    ellipsis?: boolean;
+    fixed?: boolean | string;
+    needTooltip?: boolean;
+    needCopy?: boolean;
+    needFormat?: boolean;
+    format?: string;
+    [key: string]: any;
+}
+export declare const HbTableProps: {
+    readonly columns: {
+        readonly type: PropType<ColumnType[]>;
+        readonly default: () => never[];
+        readonly required: true;
+    };
+    readonly childColumns: {
+        readonly type: PropType<ColumnType[]>;
+        readonly default: () => never[];
+    };
+    readonly rowHeight: {
+        readonly type: PropType<string | number>;
+    };
+    readonly defaultWidth: {
+        readonly type: PropType<string | number>;
+        readonly default: 150;
+    };
+};
+export type HbTablePropsType = ExtractPropTypes<typeof HbTableProps>;

package/dist/components/utils/createBem.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 创建 BEM风格的类名
+ * bem(block, element, modifier)
+ * 比如 hhb-button
+ * hhb-button__header
+ * hhb-button--primary
+ *
+ * is-disabled  is-checked
+ *
+ * */
+export declare const createNameSpace: (name?: string) => {
+    b: (block?: string) => string;
+    e: (element: string) => string;
+    m: (modifier: string) => string;
+    be: (block: string, element: string) => string;
+    em: (element: string, modifier: string) => string;
+    bem: (block: string, element: string, modifier: string) => string;
+    is: (name: string, state: string | boolean) => string;
+};

package/dist/components/utils/withInstall.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from "vue";
+type SFCWithInstall<T> = T & Plugin;
+export declare const withInstall: <T, E extends Record<string, any>>(main: T, extra?: E | undefined) => SFCWithInstall<T> & E;
+export {};