cnhis-design-vue 3.1.37-beta.2 → 3.1.37

package/es/components/iho-table/src/types/index.d.ts

@@ -0,0 +1,108 @@
+import { AnyObject, MaybeString, TupleToUnion } from '../../../../../es/shared/types';
+import { VxeTableProps, VxeTableDefines, VxeTableInstance, VxeColumnPropTypes } from 'vxe-table';
+import { VxeTableEventProps } from 'vxe-table/types/table';
+import { IHO_TABLE_STRING_STATUS, IhoTableCustomEventNameTuple, IhoTableEventNameTuple, IhoTableRowGroupSequence } from '../../../../../es/components/iho-table/src/constants';
+import { FilterState } from '../../../../../es/components/iho-table/src/plugins/filterPlugin/types';
+export * from './pluginType';
+export interface IhoTableRowGroupItem {
+    groupName?: string;
+    title: string;
+    list: string[];
+}
+export declare type IhoTableConfig = VxeTableProps & Partial<{
+    [K in EventNameToEventListener<typeof IhoTableEventNameTuple[number]>]: (...payload: IhoTableEmitPayload<EventListenerToEventName<K>>) => void;
+}> & Partial<{
+    uuid: string;
+    isTree: MaybeString<0 | 1 | 2 | 3>;
+    isBatchSelect: MaybeString<0 | 1>;
+    showSeq: boolean;
+    selectType: Exclude<VxeTableDefines.ColumnInfo['type'], 'seq' | 'expand' | 'html'>;
+    rowGroupSetting: Partial<Record<TupleToUnion<typeof IhoTableRowGroupSequence>, IhoTableRowGroupItem[]>>;
+    anchorList: string[];
+    columnConfig: {
+        seqSlotFn: VxeColumnPropTypes.Slots['default'];
+    };
+    checkboxConfig: Partial<VxeTableProps['checkboxConfig'] & {
+        slots: VxeColumnPropTypes.Slots;
+    }>;
+    [K: string]: unknown;
+}>;
+export declare type IhoTableFieldItem = {
+    [K in keyof VxeTableDefines.ColumnInfo]?: K extends 'children' ? IhoTableFieldItem[] : K extends keyof VxeTableDefines.ColumnInfo ? VxeTableDefines.ColumnInfo[K] : never;
+} & Partial<{
+    annotation: boolean;
+}>;
+export declare namespace IhoTableLowCodeField {
+    type FieldSetting = {
+        notParticipatingSearch: IHO_TABLE_STRING_STATUS;
+        mapping?: {
+            type: string;
+            mappingFiled: Array<{
+                value: Array<{
+                    options: AnyObject[];
+                }>;
+            }>;
+        };
+    };
+    type SettingObj = Partial<{
+        attr: string;
+        isHide: MaybeString<0 | 1>;
+        [K: string]: unknown;
+    }>;
+}
+export declare type LowCodeTableFieldItem = {
+    columnName: string;
+    [K: string]: unknown;
+} & Partial<{
+    id: number | string;
+    alias: string;
+    isFixed: 0 | 1 | 2;
+    colWidth: VxeTableDefines.ColumnInfo['width'];
+    settingObj: IhoTableLowCodeField.SettingObj;
+    treeNode: boolean;
+    isShow: MaybeString<0 | 1>;
+    isSort: MaybeString<0 | 1>;
+    formType: string;
+    fieldSetting: string;
+    componentProps: AnyObject;
+    options: AnyObject[];
+    annotation: boolean;
+    slotFn: NonNullable<IhoTableFieldItem['slots']>['default'];
+    headerSlotFn: NonNullable<IhoTableFieldItem['slots']>['header'];
+    editSlotFn: NonNullable<IhoTableFieldItem['slots']>['edit'];
+    filterDefaultValue: Partial<{
+        checked: string[];
+        sortStatus: null | 'asc' | 'desc';
+    }>;
+    /**
+     * 即将被废弃，请使用表格外层的beforeEditMethod属性
+     * @deprecated
+     */
+    checkEditStatus: (payload: VxeTableDefines.CellRenderBodyParams) => boolean | void;
+}> & Partial<VxeTableDefines.ColumnInfo>;
+export declare type IhoTableFormChangePayload = {
+    column: IhoTableFieldItem;
+    row: AnyObject;
+    value: unknown;
+    index: number;
+    type?: string;
+    oldValue?: unknown;
+};
+export declare type IhoTableEmits = <T extends typeof IhoTableEventNameTuple[number]>(event: T, ...args: IhoTableEmitPayload<T>) => void;
+export declare type EventListenerToEventName<T extends string> = T extends `on${infer R}` ? R extends `${infer F}${infer L}` ? `${Lowercase<F>}${L}` : never : never;
+export declare type EventNameToEventListener<T extends string> = T extends `${infer L}${infer R}` ? `on${Uppercase<L>}${R}` : never;
+export declare type IhoTableHandler = Record<'updateConfigRef' | 'updateFieldListRef' | 'updateTableDataRef', () => void>;
+export declare type IhoTableEventNameUnion = TupleToUnion<typeof IhoTableEventNameTuple>;
+export declare type IHoTableKeyboardPayload = IhoTableFormChangePayload & {
+    key: string;
+};
+export declare type IhoTableEmitPayload<T extends typeof IhoTableEventNameTuple[number]> = T extends 'formChange' | 'formClick' ? [IhoTableFormChangePayload] : T extends 'keyboard' ? [IHoTableKeyboardPayload] : T extends 'settingClick' ? [] : Parameters<NonNullable<VxeTableEventProps[EventNameToEventListener<Exclude<T, typeof IhoTableCustomEventNameTuple[number]>>]>>;
+export declare type IhoTableAnchorItem = {
+    field: string;
+    title: string;
+    left: number;
+};
+export declare type IhoTableExpose = {
+    $table: VxeTableInstance;
+    setFilterState(fieldName: string, value: Partial<Omit<FilterState, 'options'>>): void;
+};

package/es/components/iho-table/src/types/pluginType.d.ts

@@ -0,0 +1,173 @@
+import { AnyObject, ArrayAble, Func, Nullable } from '../../../../../es/shared/types';
+import { AsyncParallelHook, AsyncSeriesHook, SyncHook, SyncWaterfallHook } from '../../../../../es/shared/utils/tapable';
+import { MaybeRef } from '@vueuse/core';
+import { Ref, VNode } from 'vue';
+import { VxeGlobalCommands, VxeGlobalFormats, VxeGlobalHooks, VxeGlobalMenus, VxeGlobalRenderer, VxeTableInstance } from 'vxe-table';
+import { VxeTableEventProps, VxeTableEvents } from 'vxe-table/types/table';
+import { VxeGlobalInterceptor } from 'vxe-table/types/v-x-e-table';
+import { IhoTableConfig, IhoTableEmits, IhoTableFieldItem, IhoTableHandler } from '.';
+export declare type IhoTableInstance = {
+    interceptor: VxeGlobalInterceptor;
+    renderer: VxeGlobalRenderer;
+    commands: VxeGlobalCommands;
+    formats: VxeGlobalFormats;
+    menus: VxeGlobalMenus;
+    hooks: VxeGlobalHooks;
+};
+export declare type TablePlugin = {
+    name: string;
+    vxe?(xeTable: IhoTableInstance): void;
+    apply?(hooks: TableHooks): void;
+};
+export declare type TableHooks = Readonly<{
+    configHooks: AbstractConfigHooks;
+    fieldHooks: AbstractFieldHooks;
+    eventHooks: AbstractEventHooks;
+    dataHooks: AbstractDataHooks;
+    setupHooks: AbstractSetupHooks;
+    domInsertHooks: AbstractDomInsertHooks;
+    exposeHooks: AbstractExposeHooks;
+}>;
+export declare type WithTableConfig<T = []> = T extends any[] ? [...T, IhoTableConfig] : [T, IhoTableConfig];
+declare type ConfigHookType<T> = SyncWaterfallHook<WithTableConfig<T>>;
+export declare abstract class AbstractConfigHooks {
+    abstract readonly config: SyncWaterfallHook<IhoTableConfig>;
+    abstract readonly rowConfig: ConfigHookType<IhoTableConfig['rowConfig']>;
+    abstract readonly editConfig: ConfigHookType<IhoTableConfig['editConfig']>;
+    abstract readonly columnConfig: ConfigHookType<IhoTableConfig['columnConfig']>;
+    abstract readonly resizableConfig: ConfigHookType<IhoTableConfig['resizableConfig']>;
+    abstract readonly seqConfig: ConfigHookType<IhoTableConfig['seqConfig']>;
+    abstract readonly sortConfig: ConfigHookType<IhoTableConfig['sortConfig']>;
+    abstract readonly filterConfig: ConfigHookType<IhoTableConfig['filterConfig']>;
+    abstract readonly radioConfig: ConfigHookType<IhoTableConfig['radioConfig']>;
+    abstract readonly checkboxConfig: ConfigHookType<IhoTableConfig['checkboxConfig']>;
+    abstract readonly expandConfig: ConfigHookType<IhoTableConfig['expandConfig']>;
+    abstract readonly treeConfig: ConfigHookType<IhoTableConfig['treeConfig']>;
+    abstract readonly mouseConfig: ConfigHookType<IhoTableConfig['mouseConfig']>;
+    abstract readonly menuConfig: ConfigHookType<IhoTableConfig['menuConfig']>;
+    abstract readonly keyboardConfig: ConfigHookType<IhoTableConfig['keyboardConfig']>;
+    abstract readonly scrollY: ConfigHookType<IhoTableConfig['scrollY']>;
+    abstract readonly scrollX: ConfigHookType<IhoTableConfig['scrollX']>;
+    abstract readonly editRules: ConfigHookType<IhoTableConfig['editRules']>;
+}
+export interface FieldHookContext {
+    index: number;
+    remove(): void;
+    insertBefore(field: ArrayAble<IhoTableFieldItem>): void;
+    insertAfter(field: ArrayAble<IhoTableFieldItem>): void;
+}
+export declare type WithFieldHookContext<T = []> = [
+    ...WithTableConfig<T>,
+    {
+        $table: Ref<Nullable<VxeTableInstance>>;
+        emits: IhoTableEmits;
+    }
+];
+export declare abstract class AbstractFieldHooks {
+    abstract readonly fieldStart: AsyncParallelHook<WithFieldHookContext>;
+    abstract readonly field: SyncWaterfallHook<WithFieldHookContext<[IhoTableFieldItem, FieldHookContext]>>;
+    abstract readonly fieldList: SyncWaterfallHook<WithFieldHookContext<[IhoTableFieldItem[]]>>;
+    abstract readonly fieldEnd: AsyncParallelHook<WithFieldHookContext>;
+}
+export declare type WithIhoEventContext<T> = [
+    ...WithTableConfig<T>,
+    IhoTableHandler & {
+        $table: Nullable<VxeTableInstance>;
+        emits: IhoTableEmits;
+    }
+];
+declare type EventHookType<T extends Func> = AsyncParallelHook<WithIhoEventContext<Parameters<T>>>;
+declare type VxeEventTypes = Required<{
+    readonly [K in keyof VxeTableEventProps]: EventHookType<NonNullable<VxeTableEventProps[K]>>;
+}>;
+export declare abstract class AbstractEventHooks implements VxeEventTypes {
+    abstract readonly onKeydownStart: EventHookType<VxeTableEvents.KeydownStart>;
+    abstract readonly onKeydown: EventHookType<VxeTableEvents.Keydown>;
+    abstract readonly onKeydownEnd: EventHookType<VxeTableEvents.KeydownEnd>;
+    abstract readonly onPaste: EventHookType<VxeTableEvents.Paste>;
+    abstract readonly onCopy: EventHookType<VxeTableEvents.Copy>;
+    abstract readonly onCut: EventHookType<VxeTableEvents.Cut>;
+    abstract readonly onCurrentChange: EventHookType<VxeTableEvents.CurrentChange>;
+    abstract readonly onRadioChange: EventHookType<VxeTableEvents.RadioChange>;
+    abstract readonly onCheckboxChange: EventHookType<VxeTableEvents.CheckboxChange>;
+    abstract readonly onCheckboxAll: EventHookType<VxeTableEvents.CheckboxAll>;
+    abstract readonly onCheckboxRangeStart: EventHookType<VxeTableEvents.CheckboxRangeStart>;
+    abstract readonly onCheckboxRangeChange: EventHookType<VxeTableEvents.CheckboxRangeChange>;
+    abstract readonly onCheckboxRangeEnd: EventHookType<VxeTableEvents.CheckboxRangeEnd>;
+    abstract readonly onCellClick: EventHookType<VxeTableEvents.CellClick>;
+    abstract readonly onCellDblclick: EventHookType<VxeTableEvents.CellDblclick>;
+    abstract readonly onCellMenu: EventHookType<VxeTableEvents.CellMenu>;
+    abstract readonly onCellMouseenter: EventHookType<VxeTableEvents.CellMouseenter>;
+    abstract readonly onCellMouseleave: EventHookType<VxeTableEvents.CellMouseleave>;
+    abstract readonly onHeaderCellClick: EventHookType<VxeTableEvents.HeaderCellClick>;
+    abstract readonly onHeaderCellDblclick: EventHookType<VxeTableEvents.HeaderCellDblclick>;
+    abstract readonly onHeaderCellMenu: EventHookType<VxeTableEvents.HeaderCellMenu>;
+    abstract readonly onFooterCellClick: EventHookType<VxeTableEvents.FooterCellClick>;
+    abstract readonly onFooterCellDblclick: EventHookType<VxeTableEvents.FooterCellDblclick>;
+    abstract readonly onFooterCellMenu: EventHookType<VxeTableEvents.FooterCellMenu>;
+    abstract readonly onSortChange: EventHookType<VxeTableEvents.SortChange>;
+    abstract readonly onFilterChange: EventHookType<VxeTableEvents.FilterChange>;
+    abstract readonly onFilterVisible: EventHookType<VxeTableEvents.FilterVisible>;
+    abstract readonly onResizableChange: EventHookType<VxeTableEvents.ResizableChange>;
+    abstract readonly onToggleRowExpand: EventHookType<VxeTableEvents.ToggleRowExpand>;
+    abstract readonly onToggleTreeExpand: EventHookType<VxeTableEvents.ToggleTreeExpand>;
+    abstract readonly onMenuClick: EventHookType<VxeTableEvents.MenuClick>;
+    abstract readonly onEditClosed: EventHookType<VxeTableEvents.EditClosed>;
+    abstract readonly onEditActived: EventHookType<VxeTableEvents.EditActived>;
+    abstract readonly onEditDisabled: EventHookType<VxeTableEvents.EditDisabled>;
+    abstract readonly onValidError: EventHookType<VxeTableEvents.ValidError>;
+    abstract readonly onScroll: EventHookType<VxeTableEvents.Scroll>;
+    abstract readonly onCustom: EventHookType<VxeTableEvents.Custom>;
+    abstract readonly onOpenFnr: EventHookType<VxeTableEvents.OpenFnr>;
+    abstract readonly onFnrChange: EventHookType<VxeTableEvents.FnrChange>;
+    abstract readonly onFnrFind: EventHookType<VxeTableEvents.FnrFind>;
+    abstract readonly onFnrFindAll: EventHookType<VxeTableEvents.FnrFindAll>;
+    abstract readonly onFnrReplace: EventHookType<VxeTableEvents.FnrReplace>;
+    abstract readonly onFnrReplaceAll: EventHookType<VxeTableEvents.FnrReplaceAll>;
+    abstract readonly onCellAreaCopy: EventHookType<VxeTableEvents.CellAreaCopy>;
+    abstract readonly onCellAreaCut: EventHookType<VxeTableEvents.CellAreaCut>;
+    abstract readonly onCellAreaPaste: EventHookType<VxeTableEvents.CellAreaPaste>;
+    abstract readonly onCellAreaMerge: EventHookType<VxeTableEvents.CellAreaMerge>;
+    abstract readonly onClearCellAreaMerge: EventHookType<VxeTableEvents.ClearCellAreaMerge>;
+    abstract readonly onHeaderCellAreaSelection: EventHookType<VxeTableEvents.HeaderCellAreaSelection>;
+    abstract readonly onCellAreaSelectionStart: EventHookType<VxeTableEvents.CellAreaSelectionStart>;
+    abstract readonly onCellAreaSelectionDrag: EventHookType<VxeTableEvents.CellAreaSelectionDrag>;
+    abstract readonly onCellAreaSelectionEnd: EventHookType<VxeTableEvents.CellAreaSelectionEnd>;
+    abstract readonly onCellAreaExtensionStart: EventHookType<VxeTableEvents.CellAreaExtensionStart>;
+    abstract readonly onCellAreaExtensionDrag: EventHookType<VxeTableEvents.CellAreaExtensionDrag>;
+    abstract readonly onCellAreaExtensionEnd: EventHookType<VxeTableEvents.CellAreaExtensionEnd>;
+    abstract readonly onCellAreaArrowsStart: EventHookType<VxeTableEvents.CellAreaArrowsStart>;
+    abstract readonly onCellAreaArrowsEnd: EventHookType<VxeTableEvents.CellAreaArrowsEnd>;
+    abstract readonly onActiveCellChangeStart: EventHookType<VxeTableEvents.ActiveCellChangeStart>;
+    abstract readonly onActiveCellChangeEnd: EventHookType<VxeTableEvents.ActiveCellChangeEnd>;
+}
+declare type DataHookContext = {
+    remove(): void;
+    $table: MaybeRef<Nullable<VxeTableInstance>>;
+    index: number;
+    insertBefore(data: ArrayAble<AnyObject>): void;
+    insertAfter(data: ArrayAble<AnyObject>): void;
+};
+export declare type WithTableDataContext<T> = [...WithTableConfig<T>, DataHookContext];
+export declare abstract class AbstractDataHooks {
+    abstract readonly data: AsyncSeriesHook<WithTableDataContext<[AnyObject]>>;
+}
+export declare abstract class AbstractSetupHooks {
+    abstract readonly setup: SyncHook<[Ref<IhoTableConfig>, Ref<IhoTableFieldItem[]>]>;
+}
+export declare abstract class AbstractDomInsertHooks {
+    abstract readonly header: SyncWaterfallHook<[VNode[]]>;
+    abstract readonly footer: SyncWaterfallHook<[VNode[]]>;
+}
+export declare type WithExposeHookConfig<T = []> = [
+    ...(T extends any[] ? T : [T]),
+    Ref<IhoTableConfig>,
+    {
+        $table: Ref<Nullable<VxeTableInstance>>;
+        emits: IhoTableEmits;
+    }
+];
+export declare abstract class AbstractExposeHooks {
+    abstract readonly expose: SyncWaterfallHook<WithExposeHookConfig<Record<string, Func>>>;
+}
+export {};

package/es/components/iho-table/src/utils/index.d.ts

@@ -0,0 +1,49 @@
+import { AnyObject, Nullable } from '../../../../../es/shared/types';
+import { MaybeRef } from '@vueuse/core';
+import { VxeTableDefines, VxeTableInstance } from 'vxe-table';
+import { VxeGlobalRendererHandles } from 'vxe-table/types/v-x-e-table/renderer';
+import { EventListenerToEventName, EventNameToEventListener, IhoTableConfig, IhoTableFieldItem, LowCodeTableFieldItem } from '../../../../../es/components/iho-table';
+import { EDITABLE_WIDGET_TYPE } from '../../../../../es/components/iho-table/src/constants';
+export declare function IhoTableLog(message: string): void;
+export declare function IhoTableWarn(message: string): void;
+export declare const IhoTableUtils: Readonly<{
+    getCellType(lowCodeField: LowCodeTableFieldItem): string;
+}>;
+export declare function getRowHeight(): number;
+export declare function eventListener2EventName<T extends string>(eventListenerName: T): EventListenerToEventName<T>;
+export declare function eventName2EventListener<T extends string>(eventName: T): EventNameToEventListener<T>;
+export declare function useUUIDMap<T>(creator: () => T, isReactive?: boolean): {
+    getItemFromUUID: (uuid: string) => T;
+    removeItemFromUUID: (uuid: string) => void;
+};
+export declare function getColumnRenderWidth(column: AnyObject, $table: MaybeRef<Nullable<VxeTableInstance>>): Promise<number>;
+export declare function useIhoTableFormEvent(payload: Pick<VxeGlobalRendererHandles.RenderEditParams, 'row' | 'rowIndex' | 'column'> & {
+    $rowIndex?: number;
+}): {
+    emitFormChange: () => void;
+    emitFormClick: () => void;
+    emitFormChangeWithParams: (params?: AnyObject) => void;
+    emitFormClickWithParams: (params?: AnyObject) => void;
+};
+export declare function getLowCodeFieldFromField(field: IhoTableFieldItem): LowCodeTableFieldItem | undefined;
+declare function createDefaultRenderCell(): ((renderOpts: import("vxe-table").VxeColumnPropTypes.EditRender, params: VxeGlobalRendererHandles.RenderCellParams) => VxeGlobalRendererHandles.RenderResult) | undefined;
+declare function createRenderEdit(renderer: (payload: VxeGlobalRendererHandles.RenderEditParams & {
+    fieldItem: Partial<LowCodeTableFieldItem>;
+} & ReturnType<typeof useIhoTableFormEvent>) => VxeGlobalRendererHandles.RenderResult): ((renderOpts: import("vxe-table").VxeColumnPropTypes.EditRender, params: VxeGlobalRendererHandles.RenderEditParams) => VxeGlobalRendererHandles.RenderResult) | undefined;
+export declare const IhoTableRenderHelper: Readonly<{
+    createDefaultRenderCell: typeof createDefaultRenderCell;
+    createRenderEdit: typeof createRenderEdit;
+    isEditableColumn(config: IhoTableConfig, column: IhoTableFieldItem): boolean | undefined;
+    hasFilter(fieldSetting: unknown): boolean;
+}>;
+export declare const IhoTableStatusHelper: Readonly<{
+    isPositive(value: string | number | undefined | null): boolean;
+    isNegative(value: string | number | undefined | null): boolean;
+    notPositive(value: string | number | undefined | null): boolean;
+    notNegative(value: string | number | undefined | null): boolean;
+}>;
+export declare const createIhoTableClearActivedInterceptor: (type: EDITABLE_WIDGET_TYPE, solution: (ele: HTMLElement) => boolean) => ({ $event, column }: {
+    $event: Event;
+    column: VxeTableDefines.ColumnInfo;
+}) => boolean;
+export {};

package/es/components/index.d.ts

@@ -0,0 +1,37 @@
+import type { App } from 'vue';
+import CGrid from './grid';
+import CBigTable from './big-table';
+import CFieldSet from './field-set';
+import CButtonPrint from './button-print';
+import CSelectPerson from './select-person';
+import CSelectLabel, { CLabelFormContent } from './select-label';
+import CMap from './map';
+import CVodChunkUpload from './vod-chunk-upload';
+import { CScaleView, CRadio, CCheckbox, CSelect, CDatetime } from './scale-view';
+import CInfoHeader from './info-header';
+import CTimeLine from './time-line';
+import CBpmnWorkflow from './bpmn-workflow';
+import CStepsWheel from './steps-wheel';
+import CEditor from './editor';
+import CFormRender from './form-render';
+import CFabricChart from './fabric-chart';
+import CShortcutProvider from './shortcut-provider';
+import CShortcutSetter from './shortcut-setter';
+import CFormConfig from './form-config';
+import CIhoTable from './iho-table';
+import CKeyboard from './keyboard';
+import CSearchCascader from './search-cascader';
+import CRecommendSearch from './recommend-search';
+export * from './form-render';
+export * from './shortcut-provider';
+export * from './shortcut-setter';
+export * from './iho-table';
+export * from './button-print';
+export * from './form-config';
+export * from './insurance-sdk';
+declare function install(app: App): void;
+export { CGrid, CBigTable, CFieldSet, CButtonPrint, CSelectPerson, CSelectLabel, CLabelFormContent, CScaleView, CMap, CVodChunkUpload, CRadio, CCheckbox, CSelect, CDatetime, CInfoHeader, CTimeLine, CBpmnWorkflow, CStepsWheel, CEditor, CFormRender, CFabricChart, CShortcutProvider, CShortcutSetter, CFormConfig, CIhoTable, CKeyboard, CSearchCascader, CRecommendSearch };
+declare const _default: {
+    install: typeof install;
+};
+export default _default;