@farris/ui-vue 1.0.0-beta.6 → 1.0.1

package/types/time-picker/index.d.ts

@@ -0,0 +1,11 @@
+import type { App } from 'vue';
+import TimePicker from './src/time-picker.component';
+import TimePickerTimeView from './src/components/time.component';
+export * from './src/time-picker.props';
+export * from './src/components/time.props';
+export { TimePicker, TimePickerTimeView };
+declare const _default: {
+    install(app: App): void;
+    register(componentMap: Record<string, any>, propsResolverMap: Record<string, any>): void;
+};
+export default _default;

package/types/time-picker/src/components/time-holder.d.ts

@@ -0,0 +1,82 @@
+export declare class TimeHolder {
+    hourStep: number;
+    minuteStep: number;
+    secondStep: number;
+    use12Hours: boolean;
+    private _hours;
+    /**
+     * @description
+     * Same as realHours
+     * @see realHours
+     */
+    get hours(): number | undefined;
+    /**
+     * @description
+     * Set viewHours to realHours
+     */
+    set hours(value: number | undefined);
+    /**
+     * @description
+     * Value hours
+     * Get realHours and its range is [0, 1, 2, ..., 22, 23]
+     */
+    get realHours(): number | undefined;
+    /**
+     * @description
+     * UI view hours
+     * Get viewHours which is selected in `time-picker-panel` and its range is [12, 1, 2, ..., 11]
+     */
+    get viewHours(): number | undefined;
+    private _minutes;
+    get minutes(): number | undefined;
+    set minutes(value: number | undefined);
+    private _seconds;
+    get seconds(): number | undefined;
+    set seconds(value: number | undefined);
+    /**
+     * @description
+     * Same as defaultRealHours
+     */
+    get defaultHours(): number;
+    /**
+     * @description
+     * Get deafultViewHours when defaultOpenValue is setted
+     * @see viewHours
+     */
+    get defaultViewHours(): number;
+    /**
+     * @description
+     * Get defaultRealHours when defaultOpenValue is setted
+     * @see realHours
+     */
+    get defaultRealHours(): number;
+    get defaultMinutes(): number;
+    get defaultSeconds(): number;
+    get default12Hours(): string;
+    private _text;
+    get text(): string;
+    set text(value: string);
+    private _value;
+    get value(): Date | undefined;
+    set value(value: Date | undefined);
+    private _selected12Hours;
+    get selected12Hours(): string | undefined;
+    set selected12Hours(value: string | undefined);
+    private _defaultOpenValue;
+    get defaultOpenValue(): Date;
+    set defaultOpenValue(value: Date);
+    get isEmpty(): boolean;
+    constructor();
+    setHours(value: number, disabled: boolean): this;
+    setUse12Hours(value: boolean): this;
+    setMinutes(value: number, disabled: boolean): this;
+    setSeconds(value: number, disabled: boolean): this;
+    setValue(value: Date | undefined, use12Hours?: boolean): this;
+    setValueByStep(value: number, step: number): number;
+    setDefaultOpenValue(value: Date): this;
+    setDefaultValueIfNil(): void;
+    private update;
+    private clearTimeValue;
+    clear(): void;
+    private calculateViewHour;
+}

package/types/time-picker/src/components/time.props.d.ts

@@ -0,0 +1,48 @@
+import { ExtractPropTypes } from 'vue';
+export declare const timeProps: {
+    hourStep: {
+        Type: NumberConstructor;
+        default: number;
+    };
+    minuteStep: {
+        Type: NumberConstructor;
+        default: number;
+    };
+    secondStep: {
+        Type: NumberConstructor;
+        default: number;
+    };
+    clearText: {
+        Type: StringConstructor;
+        default: string;
+    };
+    popupClassName: {
+        Type: StringConstructor;
+        default: string;
+    };
+    placeholder: {
+        Type: StringConstructor;
+        default: string;
+    };
+    defaultOpenValue: {
+        Type: DateConstructor;
+        default: Date;
+    };
+    format: {
+        Type: StringConstructor;
+        default: string;
+    };
+    isOpen: {
+        Type: BooleanConstructor;
+        default: boolean;
+    };
+    use12Hours: {
+        Type: BooleanConstructor;
+        default: boolean;
+    };
+    hideDisabledOptions: {
+        Type: BooleanConstructor;
+        default: boolean;
+    };
+};
+export type TimeProps = ExtractPropTypes<typeof timeProps>;

package/types/time-picker/src/components/utils/check.d.ts

@@ -0,0 +1 @@
+export declare function isNotNil(value: any): boolean;

package/types/time-picker/src/schema/schema-mapper.d.ts

@@ -0,0 +1,2 @@
+import { MapperFunction } from '../../../dynamic-resolver';
+export declare const schemaMapper: Map<string, string | MapperFunction>;

package/types/time-picker/src/time-picker.props.d.ts

@@ -0,0 +1,4 @@
+import { ExtractPropTypes } from 'vue';
+export declare const timePickerProps: Record<string, any>;
+export type TimePickerProps = ExtractPropTypes<typeof timePickerProps>;
+export declare const propsResolver: (schemaValue: Record<string, any>) => Record<string, any>;

package/types/transfer/index.d.ts

@@ -0,0 +1,8 @@
+import { App } from 'vue';
+import Transfer from './src/transfer.component';
+export * from './src/transfer.props';
+export { Transfer };
+declare const _default: {
+    install(app: App): void;
+};
+export default _default;

package/types/transfer/src/transfer.props.d.ts

@@ -0,0 +1,71 @@
+import { ExtractPropTypes } from "vue";
+export declare const transferProps: {
+    dataSource: {
+        type: {
+            (arrayLength: number): object[];
+            (...items: object[]): object[];
+            new (arrayLength: number): object[];
+            new (...items: object[]): object[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: never[];
+    };
+    displayType: {
+        type: StringConstructor;
+        default: string;
+    };
+    enableSearch: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    identifyField: {
+        type: StringConstructor;
+        default: string;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    selections: {
+        type: {
+            (arrayLength: number): object[];
+            (...items: object[]): object[];
+            new (arrayLength: number): object[];
+            new (...items: object[]): object[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: never[];
+    };
+    selectionValues: {
+        type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: never[];
+    };
+};
+export type TransferProps = ExtractPropTypes<typeof transferProps>;

package/types/tree-view/index.d.ts

@@ -0,0 +1,8 @@
+import type { App } from 'vue';
+import FTreeView from './src/tree-view.component';
+export * from './src/tree-view.props';
+export { FTreeView };
+declare const _default: {
+    install(app: App): void;
+};
+export default _default;

package/types/tree-view/src/components/data/control-tree-view.component.d.ts

@@ -0,0 +1,108 @@
+declare const _default: import("vue").DefineComponent<{
+    data2: {
+        type: ObjectConstructor;
+        default: never[];
+    };
+    data: {
+        type: ObjectConstructor;
+        default: never[];
+    };
+    treeNodeIconsData: {
+        type: ObjectConstructor;
+        default: {};
+    };
+    selectable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    autoCheckChildren: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    cascade: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showTreeNodeIcons: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showLines: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    newDataItem: {
+        type: ObjectConstructor;
+        default: {};
+    };
+    lineColor: {
+        type: StringConstructor; /** 树表是否支持可选状态 */
+        default: string;
+    };
+    cellHeight: {
+        type: NumberConstructor;
+        /** 选中父节点会自动选中子节点 */
+        default: number;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, string[], string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    data2: {
+        type: ObjectConstructor;
+        default: never[];
+    };
+    data: {
+        type: ObjectConstructor;
+        default: never[];
+    };
+    treeNodeIconsData: {
+        type: ObjectConstructor;
+        default: {};
+    };
+    selectable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    autoCheckChildren: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    cascade: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showTreeNodeIcons: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showLines: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    newDataItem: {
+        type: ObjectConstructor;
+        default: {};
+    };
+    lineColor: {
+        type: StringConstructor; /** 树表是否支持可选状态 */
+        default: string;
+    };
+    cellHeight: {
+        type: NumberConstructor;
+        /** 选中父节点会自动选中子节点 */
+        default: number;
+    };
+}>> & {
+    [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+}, {
+    data: Record<string, any>;
+    selectable: boolean;
+    newDataItem: Record<string, any>;
+    treeNodeIconsData: Record<string, any>;
+    autoCheckChildren: boolean;
+    cascade: boolean;
+    showTreeNodeIcons: boolean;
+    showLines: boolean;
+    lineColor: string;
+    cellHeight: number;
+    data2: Record<string, any>;
+}>;
+export default _default;

package/types/tree-view/src/components/data/tree-area.component.d.ts

@@ -0,0 +1,8 @@
+import { Ref, SetupContext } from 'vue';
+import { TreeViewProps } from '../../tree-view.props';
+/** 渲染树状区域 */
+export default function (props: TreeViewProps, context: SetupContext, treeNodeIconsData: Ref<any>, visibleDatas: Ref<any>): {
+    renderTreeArea: () => JSX.Element;
+    outputValue: any;
+    dictTree: any;
+};

package/types/tree-view/src/composition/types.d.ts

@@ -0,0 +1,97 @@
+import { ComputedRef, Ref } from 'vue';
+export declare enum TreeNodeCellMode {
+    readonly = 0,
+    editable = 1,
+    editing = 2
+}
+export interface VisualTreeNodeCell {
+    /** 实际高度 */
+    actualHeight?: number;
+    /** 单元格高度 */
+    cellHeight?: number;
+    /** 单元格数据 */
+    data: any;
+    /** 获取编辑器函数 */
+    getEditor: (cell: VisualTreeNodeCell) => any;
+    /** 单元格字段 */
+    field: string;
+    /** 单元格索引 */
+    index: number;
+    /** 单元格编辑模式 */
+    mode: TreeNodeCellMode;
+    /**  层级 */
+    layer: any;
+    /** 父级对象的id */
+    parentId: any;
+    /** 引用 */
+    ref?: any;
+    /** 是否被勾选 */
+    checked?: boolean;
+    /** 设置引用函数 */
+    setRef: (vnode: any) => void;
+    /** 更新函数 */
+    update: (value: any) => void;
+}
+export interface VisualTreeNode {
+    /**  是否折叠 */
+    collapse: boolean;
+    /** 数据信息 */
+    data: Record<string, VisualTreeNodeCell>;
+    /** 数据索引 */
+    dataIndex: number;
+    /** 是否展示该节点 */
+    show: boolean;
+    /**  详细信息 */
+    details?: VisualTreeNode[];
+    height?: number;
+    index: number;
+    /** 层级 */
+    layer: number;
+    /** 前一个节点 */
+    pre?: any;
+    /** 是否被选中 */
+    selected: boolean;
+    ref?: any;
+    /** 刷新键 */
+    refreshKey?: string;
+    setRef: (vnode: any) => void;
+    top: number;
+}
+export interface UseVirtualScroll {
+    onMouseDownScrollThumb: ($event: MouseEvent, treeContentRef: Ref<any>, thumbType: 'vertical' | 'horizontal') => void;
+    horizontalScrollThumbStyle: ComputedRef<Record<string, any>>;
+    verticalScrollThumbStyle: ComputedRef<Record<string, any>>;
+}
+export interface UseTreeDataView {
+    collapse: (collapseField: string, collapseValue: any) => any[];
+    dataView: Ref<any[]>;
+    expand: (expandField: string, expandValue: any) => any[];
+    addNewDataItem: (newDataItem: any) => any;
+    removeDataItem: (deleteIndex: number, dictTree: any) => any;
+    editDataItem: (editIndex: string | number, newName: string) => void;
+}
+export interface UseVisualTreeNode {
+    maxLayer?: number;
+    visibleTreeNodes: any;
+}
+export interface useTreeNodeIcon {
+    treeNodeIconsClass: (visualTreeNode: VisualTreeNode, visualTreeNodeCell: VisualTreeNodeCell, leafNodes: any) => any[];
+}
+export interface UseTreeNodeLines {
+    leafNodes: any;
+    getPaddingBottom: (dictTree: any) => any[];
+    getPaddingBottomLength: (index: number, halfBorderNodes: Array<string>) => any[];
+    handlePaddingBottomReturnValue: (index: number, leafNodes: any) => any[];
+    handleCollapsedPaddingBottom: (index: number) => any[];
+    getLeafNodes: (dictTree: any) => any[];
+}
+export interface useAutoCheckChildrenAndCascade {
+    onClickTreeNodeSelectableCell: (payload: any, visualTreeNode: any, visualTreeNodeCell: VisualTreeNodeCell, dictTree: any) => any[];
+}
+export interface UseDataList {
+    addNewDataItem: (newDataItem: any) => any;
+    removeDataItem: () => void;
+    editDataItem: () => void;
+    acceptDataItem: () => void;
+    cancelDataItem: () => void;
+}

package/types/tree-view/src/composition/use-auto-check-children-and-cascade.d.ts

@@ -0,0 +1,4 @@
+import { SetupContext } from 'vue';
+import { TreeViewProps } from '../tree-view.props';
+/** 用于处理树自动勾选子节点和优先返回父节点相关功能 */
+export declare function useAutoCheckChildrenAndCascade(props: TreeViewProps, visibleDatasValue: any, dictTree: any, maxLayer: number, context: SetupContext): any;

package/types/tree-view/src/composition/use-tree-data-view.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) 2020 - present, Inspur Genersoft Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { UseTreeDataView } from './types';
+import { SetupContext } from 'vue';
+import { TreeViewProps } from '../tree-view.props';
+export type DataViewFilter = (dataItem: any) => boolean;
+/** 处理树状数据的数据视图 */
+export declare function useTreeDataView(props: TreeViewProps, context: SetupContext): UseTreeDataView;

package/types/tree-view/src/composition/use-tree-node-icon.d.ts

@@ -0,0 +1,4 @@
+import { Ref } from 'vue';
+import { TreeViewProps } from '../tree-view.props';
+/** 用于处理树节点图标相关功能 */
+export declare function useTreeNodeIcon(props: TreeViewProps, treeNodeIconsData: Ref<any>): any;

package/types/tree-view/src/composition/use-tree-node-lines.d.ts

@@ -0,0 +1,3 @@
+import { TreeViewProps } from '../tree-view.props';
+/** 用于处理树节点连接线相关功能 */
+export declare function useTreeNodeLines(props: TreeViewProps, visibleDatas: any, dictTree: any): any;

package/types/tree-view/src/composition/use-visual-tree-node.d.ts

@@ -0,0 +1,9 @@
+import { UseTreeDataView, UseVisualTreeNode } from './types';
+import { TreeViewProps } from '../tree-view.props';
+/** 用于处理可视化树节点相关功能
+ * @param treeDataViewComposition 树状数据的数据视图
+ */
+/** 用于处理可视化树节点相关功能
+ * @param treeDataViewComposition 树状数据的数据视图
+ */
+export declare function useVisualTreeNode(props: TreeViewProps, treeDataViewComposition: UseTreeDataView): UseVisualTreeNode;

package/types/tree-view/src/control-tree-view.props.d.ts

@@ -0,0 +1,58 @@
+import { ExtractPropTypes } from 'vue';
+export declare const controlTreeViewProps: {
+    data2: {
+        type: ObjectConstructor;
+        default: never[];
+    };
+    /** 树表数据 */
+    data: {
+        type: ObjectConstructor;
+        default: never[];
+    };
+    /** 树节点图标数据 */
+    treeNodeIconsData: {
+        type: ObjectConstructor;
+        default: {};
+    };
+    /** 树表是否支持可选状态 */
+    selectable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** 选中父节点会自动选中子节点 */
+    autoCheckChildren: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** 返回值展示父节点和子节点 */
+    cascade: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** 是否显示图标集 */
+    showTreeNodeIcons: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** 是否显示连接线 */
+    showLines: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** 新增值 */
+    newDataItem: {
+        type: ObjectConstructor;
+        default: {};
+    };
+    /** 连接线颜色 */
+    lineColor: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** 单元格高度 */
+    cellHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+};
+export type ControlTreeViewProps = ExtractPropTypes<typeof controlTreeViewProps>;

package/types/tree-view/src/tree-view.component.d.ts

@@ -0,0 +1,97 @@
+declare const _default: import("vue").DefineComponent<{
+    data: {
+        type: ObjectConstructor;
+        default: never[];
+    };
+    treeNodeIconsData: {
+        type: ObjectConstructor;
+        default: {};
+    };
+    selectable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    autoCheckChildren: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    cascade: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showTreeNodeIcons: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showLines: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    newDataItem: {
+        type: ObjectConstructor;
+        default: {};
+    };
+    lineColor: {
+        type: StringConstructor;
+        default: string;
+    };
+    cellHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, string[], string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    data: {
+        type: ObjectConstructor;
+        default: never[];
+    };
+    treeNodeIconsData: {
+        type: ObjectConstructor;
+        default: {};
+    };
+    selectable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    autoCheckChildren: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    cascade: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showTreeNodeIcons: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showLines: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    newDataItem: {
+        type: ObjectConstructor;
+        default: {};
+    };
+    lineColor: {
+        type: StringConstructor;
+        default: string;
+    };
+    cellHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & {
+    [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+}, {
+    data: Record<string, any>;
+    selectable: boolean;
+    newDataItem: Record<string, any>;
+    treeNodeIconsData: Record<string, any>;
+    autoCheckChildren: boolean;
+    cascade: boolean;
+    showTreeNodeIcons: boolean;
+    showLines: boolean;
+    lineColor: string;
+    cellHeight: number;
+}>;
+export default _default;