@gct-paas/v-ben 0.1.4-dev.10 → 0.1.4-dev.11

package/es/components/v-ben-table/src/types/table.d.ts

@@ -0,0 +1,356 @@
+import { VNodeChild, EmitFn } from 'vue';
+import { PaginationProps } from './pagination';
+import { TableRowSelection as ITableRowSelection, ColumnFilterItem } from 'ant-design-vue/lib/table/interface';
+import { ColumnProps } from 'ant-design-vue/lib/table';
+import { ComponentType } from './componentType';
+import { RoleEnum } from '@gct-paas/core';
+export type VueNode = VNodeChild | JSX.Element;
+export declare type SortOrder = 'ascend' | 'descend';
+export type { ColumnFilterItem };
+export interface TableCurrentDataSource<T = Recordable> {
+    currentDataSource: T[];
+}
+export interface TableRowSelection<T = unknown> extends ITableRowSelection {
+    /**
+     * Callback executed when selected rows change
+     * @type Function
+     */
+    onChange?: (selectedRowKeys: (string | number)[], selectedRows: T[]) => unknown;
+    /**
+     * Callback executed when select/deselect one row
+     * @type Function
+     */
+    onSelect?: (record: T, selected: boolean, selectedRows: object[], nativeEvent: Event) => IObject;
+    /**
+     * Callback executed when select/deselect all rows
+     * @type Function
+     */
+    onSelectAll?: (selected: boolean, selectedRows: T[], changeRows: T[]) => IObject;
+    /**
+     * Callback executed when row selection is inverted
+     * @type Function
+     */
+    onSelectInvert?: (selectedRows: (string | number)[]) => unknown;
+}
+export interface ExpandedRowRenderRecord<T> extends TableCustomRecord<T> {
+    indent?: number;
+    expanded?: boolean;
+}
+export interface TableCustomRecord<T = Recordable> {
+    record?: T;
+    index?: number;
+}
+export interface SorterResult {
+    column: ColumnProps;
+    order: SortOrder;
+    field: string;
+    columnKey: string;
+}
+export interface FetchParams {
+    searchInfo?: Recordable;
+    page?: number;
+    sortInfo?: Recordable;
+    filterInfo?: Recordable;
+}
+export interface GetColumnsParams {
+    ignoreIndex?: boolean;
+    ignoreAction?: boolean;
+    sort?: boolean;
+}
+export type SizeType = 'default' | 'middle' | 'small' | 'large';
+export interface TableActionType {
+    reload: (opt?: FetchParams) => Promise<void>;
+    setSelectedRows: (rows: Recordable[]) => void;
+    getSelectRows: <T = Recordable>() => T[];
+    clearSelectedRowKeys: () => void;
+    expandAll: () => void;
+    expandRows: (keys: string[] | number[]) => void;
+    collapseAll: () => void;
+    scrollTo: (pos: string) => void;
+    getSelectRowKeys: () => string[];
+    deleteSelectRowByKey: (key: string) => void;
+    setPagination: (info: Partial<PaginationProps>) => void;
+    setTableData: <T = Recordable>(values: T[]) => void;
+    updateTableDataRecord: (rowKey: string | number, record: Recordable) => Recordable | unknown;
+    deleteTableDataRecord: (rowKey: string | number | string[] | number[]) => void;
+    insertTableDataRecord: (record: Recordable | Recordable[], index?: number) => Recordable[] | unknown;
+    findTableDataRecord: (rowKey: string | number) => Recordable | unknown;
+    getColumns: (opt?: GetColumnsParams) => BasicColumn[];
+    setColumns: (columns: BasicColumn[] | string[]) => void;
+    getDataSource: <T = Recordable>() => T[];
+    getRawDataSource: <T = Recordable>() => T;
+    setLoading: (loading: boolean) => void;
+    setProps: (props: Partial<BasicTableProps>) => void;
+    redoHeight: () => void;
+    setSelectedRowKeys: (rowKeys: string[] | number[]) => void;
+    getPaginationRef: () => PaginationProps | boolean;
+    getSize: () => SizeType;
+    getRowSelection: () => TableRowSelection<Recordable>;
+    getCacheColumns: () => BasicColumn[];
+    emit?: EmitFn;
+    updateTableData: (index: number, key: string, value: unknown) => Recordable;
+    setShowPagination: (show: boolean) => Promise<void>;
+    getShowPagination: () => boolean;
+    setCacheColumnsByField?: (dataIndex: string | undefined, value: BasicColumn) => void;
+    setCacheColumns?: (columns: BasicColumn[]) => void;
+}
+export interface FetchSetting {
+    pageField: string;
+    sizeField: string;
+    listField: string;
+    totalField: string;
+}
+export interface TableSetting {
+    redo?: boolean;
+    size?: boolean;
+    setting?: boolean;
+    fullScreen?: boolean;
+}
+export interface BasicTableProps<T = unknown> {
+    clickToRowSelect?: boolean;
+    isTreeTable?: boolean;
+    sortFn?: (sortInfo: SorterResult) => IObject;
+    filterFn?: (data: Partial<Recordable<string[]>>) => IObject;
+    inset?: boolean;
+    showTableSetting?: boolean;
+    tableSetting?: TableSetting;
+    striped?: boolean;
+    autoCreateKey?: boolean;
+    summaryFunc?: (...arg: unknown[]) => Recordable[];
+    summaryData?: Recordable[];
+    showSummary?: boolean;
+    canColDrag?: boolean;
+    api?: (...arg: unknown[]) => Promise<IObject>;
+    beforeFetch?: Fn;
+    afterFetch?: Fn;
+    handleSearchInfoFn?: Fn;
+    fetchSetting?: Partial<FetchSetting>;
+    immediate?: boolean;
+    emptyDataIsShowTable?: boolean;
+    searchInfo?: Recordable;
+    defSort?: Recordable;
+    useSearchForm?: boolean;
+    formConfig?: Partial<IObject>;
+    columns: BasicColumn[];
+    showIndexColumn?: boolean;
+    indexColumnProps?: BasicColumn;
+    actionColumn?: BasicColumn;
+    ellipsis?: boolean;
+    isCanResizeParent?: boolean;
+    canResize?: boolean;
+    resizeHeightOffset?: number;
+    clearSelectOnPageChange?: boolean;
+    rowKey?: string | ((record: Recordable) => string);
+    dataSource?: Recordable[];
+    titleHelpMessage?: string | string[];
+    maxHeight?: number;
+    bordered?: boolean;
+    pagination?: PaginationProps | boolean;
+    loading?: boolean;
+    /**
+     * The column contains children to display
+     * @default 'children'
+     * @type string | string[]
+     */
+    childrenColumnName?: string;
+    /**
+     * Override default table elements
+     * @type object
+     */
+    components?: object;
+    /**
+     * Expand all rows initially
+     * @default false
+     * @type boolean
+     */
+    defaultExpandAllRows?: boolean;
+    /**
+     * Initial expanded row keys
+     * @type string[]
+     */
+    defaultExpandedRowKeys?: string[];
+    /**
+     * Current expanded row keys
+     * @type string[]
+     */
+    expandedRowKeys?: string[];
+    /**
+     * Expanded container render for each row
+     * @type Function
+     */
+    expandedRowRender?: (record?: ExpandedRowRenderRecord<T>) => VNodeChild | JSX.Element;
+    /**
+     * Customize row expand Icon.
+     * @type Function | VNodeChild
+     */
+    expandIcon?: Fn | VNodeChild | JSX.Element;
+    /**
+     * Whether to expand row by clicking anywhere in the whole row
+     * @default false
+     * @type boolean
+     */
+    expandRowByClick?: boolean;
+    /**
+     * The index of `expandIcon` which column will be inserted when `expandIconAsCell` is false. default 0
+     */
+    expandIconColumnIndex?: number;
+    /**
+     * Table footer renderer
+     * @type Function | VNodeChild
+     */
+    footer?: Fn | VNodeChild | JSX.Element;
+    /**
+     * Indent size in pixels of tree data
+     * @default 15
+     * @type number
+     */
+    indentSize?: number;
+    /**
+     * i18n text including filter, sort, empty text, etc
+     * @default { filterConfirm: 'Ok', filterReset: 'Reset', emptyText: 'No Data' }
+     * @type object
+     */
+    locale?: object;
+    /**
+     * Row's className
+     * @type Function
+     */
+    rowClassName?: (record: TableCustomRecord<T>, index: number) => string;
+    /**
+     * Row selection config
+     * @type object
+     */
+    rowSelection?: TableRowSelection;
+    /**
+     * Set horizontal or vertical scrolling, can also be used to specify the width and height of the scroll area.
+     * It is recommended to set a number for x, if you want to set it to true,
+     * you need to add style .ant-table td { white-space: nowrap; }.
+     * @type object
+     */
+    scroll?: {
+        x?: number | string | true;
+        y?: number | string;
+    };
+    /**
+     * Whether to show table header
+     * @default true
+     * @type boolean
+     */
+    showHeader?: boolean;
+    /**
+     * Size of table
+     * @default 'default'
+     * @type string
+     */
+    size?: SizeType;
+    /**
+     * Table title renderer
+     * @type Function | ScopedSlot
+     */
+    title?: VNodeChild | JSX.Element | string | ((data: Recordable) => string);
+    /**
+     * Set props on per header row
+     * @type Function
+     */
+    customHeaderRow?: (column: ColumnProps, index: number) => object;
+    /**
+     * Set props on per row
+     * @type Function
+     */
+    customRow?: (record: T, index: number) => object;
+    /**
+     * `table-layout` attribute of table element
+     * `fixed` when header/columns are fixed, or using `column.ellipsis`
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/CSS/table-layout
+     * @version 1.5.0
+     */
+    tableLayout?: 'auto' | 'fixed' | string;
+    /**
+     * the render container of dropdowns in table
+     * @param triggerNode
+     * @version 1.5.0
+     */
+    getPopupContainer?: (triggerNode?: HTMLElement) => HTMLElement;
+    /**
+     * Data can be changed again before rendering.
+     * The default configuration of general user empty data.
+     * You can configured globally through [ConfigProvider](https://antdv.com/components/config-provider-cn/)
+     *
+     * @version 1.5.4
+     */
+    transformCellText?: Fn;
+    /**
+     * Callback executed before editable cell submit value, not for row-editor
+     *
+     * The cell will not submit data while callback return false
+     */
+    beforeEditSubmit?: (data: {
+        record: Recordable;
+        index: number;
+        key: string | number;
+        value: unknown;
+    }) => Promise<IObject>;
+    /**
+     * Callback executed when pagination, filters or sorter is changed
+     * @param pagination
+     * @param filters
+     * @param sorter
+     * @param currentDataSource
+     */
+    onChange?: (pagination: IObject, filters: Fn, sorter: IObject, extra: IObject) => void;
+    /**
+     * Callback executed when the row expand icon is clicked
+     *
+     * @param expanded
+     * @param record
+     */
+    onExpand?: (expande: boolean, record: T) => void;
+    /**
+     * Callback executed when the expanded rows change
+     * @param expandedRows
+     */
+    onExpandedRowsChange?: (expandedRows: string[] | number[]) => void;
+    onColumnsChange?: (data: ColumnChangeParam[]) => void;
+}
+export type CellFormat = string | ((text: string, record: Recordable, index: number) => string | number) | Map<string | number, unknown>;
+export interface BasicColumn extends ColumnProps<Recordable> {
+    children?: BasicColumn[];
+    filters?: ColumnFilterItem[];
+    flag?: 'INDEX' | 'DEFAULT' | 'CHECKBOX' | 'RADIO' | 'ACTION';
+    customTitle?: VueNode;
+    slots?: Recordable;
+    defaultHidden?: boolean;
+    helpMessage?: string | string[];
+    format?: CellFormat;
+    edit?: boolean;
+    editRow?: boolean;
+    editable?: boolean;
+    editComponent?: ComponentType;
+    editComponentProps?: ((opt: {
+        text: string | number | boolean | Recordable;
+        record: Recordable;
+        column: BasicColumn;
+        index: number;
+    }) => Recordable) | Recordable;
+    editRule?: boolean | ((text: string, record: Recordable) => Promise<string>);
+    editValueMap?: (value: unknown) => string;
+    onEditRow?: () => void;
+    auth?: RoleEnum | RoleEnum[] | string | string[];
+    ifShow?: boolean | ((column: BasicColumn) => boolean);
+    editRender?: (opt: {
+        text: string | number | boolean | Recordable;
+        record: Recordable;
+        column: BasicColumn;
+        index: number;
+    }) => VNodeChild | JSX.Element;
+    editDynamicDisabled?: boolean | ((record: Recordable) => boolean);
+}
+export interface ColumnChangeParam {
+    dataIndex: string;
+    fixed: boolean | 'left' | 'right' | undefined;
+    visible: boolean;
+}
+export interface InnerHandlers {
+    onColumnsChange: (data: ColumnChangeParam[]) => void;
+}

package/es/components/v-ben-table/src/types/tableAction.d.ts

@@ -0,0 +1,24 @@
+import { ButtonProps } from 'ant-design-vue/es/button/buttonTypes';
+import { TooltipProps } from 'ant-design-vue/es/tooltip/Tooltip';
+import { RoleEnum } from '@gct-paas/core';
+export interface ActionItem extends ButtonProps {
+    onClick?: Fn;
+    label?: string;
+    color?: 'success' | 'error' | 'warning' | 'text';
+    icon?: string;
+    popConfirm?: PopConfirm;
+    disabled?: boolean;
+    divider?: boolean;
+    auth?: RoleEnum | string;
+    ifShow?: boolean | ((action: ActionItem) => boolean);
+    tooltip?: string | TooltipProps;
+}
+export interface PopConfirm {
+    title: string;
+    okText?: string;
+    cancelText?: string;
+    confirm: Fn;
+    cancel?: Fn;
+    icon?: string;
+    placement?: 'top' | 'left' | 'right' | 'bottom' | 'topLeft' | 'topRight' | 'leftTop' | 'leftBottom' | 'rightTop' | 'rightBottom' | 'bottomLeft' | 'bottomRight';
+}

package/es/hooks/useDesign.d.ts

@@ -0,0 +1,5 @@
+export declare const prefixCls = "vben";
+export declare function useDesign(scope: string): {
+    prefixCls: string;
+    prefixVar: string;
+};

package/es/hooks/useDesign.mjs

@@ -0,0 +1,9 @@
+const prefixCls = "vben";
+function useDesign(scope) {
+  return {
+    prefixCls: `${prefixCls}-${scope}`,
+    prefixVar: prefixCls
+  };
+}
+
+export { prefixCls, useDesign };

package/es/index.d.ts

@@ -1 +1,3 @@
+export * from './utils/is';
+export * from './components';
 export declare function run(): void;

package/es/index.mjs

@@ -1,3 +1,13 @@
+import './components/v-ben-table/src/components/TableActionAuto.css';import './components/v-ben-table/src/components/TableAction.css';export { is, isArray, isBoolean, isClient, isDate, isDef, isElement, isEmpty, isEmptyStr, isFunction, isMap, isNull, isNullAndUnDef, isNullOrUnDef, isNumber, isObject, isPromise, isRegExp, isServer, isString, isUnDef, isUrl, isWindow } from './utils/is.mjs';
+export { default as BasicTable } from './components/v-ben-table/src/BasicTable.vue.mjs';
+export { default as TableAction } from './components/v-ben-table/src/components/TableAction.vue.mjs';
+/* empty css                                                        */
+export { default as TableActionAuto } from './components/v-ben-table/src/components/TableActionAuto.vue.mjs';
+/* empty css                                                            */
+export { Button, PopConfirmButton } from './components/v-ben-button/index.mjs';
+export { Dropdown } from './components/v-ben-dropdown/index.mjs';
+export { default as CustomButton } from './components/v-ben-button/src/custom-button.vue.mjs';
+
 function run() {
 }
 

package/es/types/index.d.ts

@@ -0,0 +1,18 @@
+import '@gct-paas/core/types';
+import type { VNode, ComponentPublicInstance } from 'vue';
+
+declare global {
+  namespace JSX {
+    type Element = VNode;
+    type ElementClass = ComponentPublicInstance;
+
+    interface ElementAttributesProperty {
+      $props: IObject;
+    }
+
+    type IntrinsicElements = IObject;
+
+    type IntrinsicAttributes = IObject;
+  }
+  declare type Recordable<T = unknown> = Record<string, T>;
+}

package/es/utils/is.d.ts

@@ -0,0 +1,23 @@
+export declare function is(val: unknown, type: string): boolean;
+export declare function isDef<T = unknown>(val?: T): val is T;
+export declare function isUnDef<T = unknown>(val?: T): val is T;
+export declare function isObject(val: unknown): boolean;
+export declare function isEmpty<T = unknown>(val: T): val is T;
+export declare function isDate(val: unknown): val is Date;
+export declare function isNull(val: unknown): val is null;
+export declare function isNullAndUnDef(val: unknown): val is null | undefined;
+export declare function isNullOrUnDef(val: unknown): val is null | undefined;
+export declare function isNumber(val: unknown): val is number;
+export declare function isPromise<T = IObject>(val: unknown): val is Promise<T>;
+export declare function isString(val: unknown): val is string;
+export declare function isFunction(val: unknown): val is Fn;
+export declare function isBoolean(val: unknown): val is boolean;
+export declare function isRegExp(val: unknown): val is RegExp;
+export declare function isArray(val: unknown): boolean;
+export declare function isWindow(val: unknown): val is Window;
+export declare function isElement(val: unknown): val is Element;
+export declare function isMap(val: unknown): boolean;
+export declare const isServer: boolean;
+export declare const isClient: boolean;
+export declare function isUrl(path: string): boolean;
+export declare function isEmptyStr(str: unknown): boolean;

package/es/utils/is.mjs

@@ -0,0 +1,78 @@
+const toString = Object.prototype.toString;
+function is(val, type) {
+  return toString.call(val) === `[object ${type}]`;
+}
+function isDef(val) {
+  return typeof val !== "undefined";
+}
+function isUnDef(val) {
+  return !isDef(val);
+}
+function isObject(val) {
+  return val !== null && is(val, "Object");
+}
+function isEmpty(val) {
+  if (isArray(val) || isString(val)) {
+    return val.length === 0;
+  }
+  if (val instanceof Map || val instanceof Set) {
+    return val.size === 0;
+  }
+  if (isObject(val)) {
+    return Object.keys(val).length === 0;
+  }
+  return false;
+}
+function isDate(val) {
+  return is(val, "Date");
+}
+function isNull(val) {
+  return val === null;
+}
+function isNullAndUnDef(val) {
+  return isUnDef(val) && isNull(val);
+}
+function isNullOrUnDef(val) {
+  return isUnDef(val) || isNull(val);
+}
+function isNumber(val) {
+  return is(val, "Number");
+}
+function isPromise(val) {
+  return is(val, "Promise") && isObject(val) && isFunction(val.then) && isFunction(val.then);
+}
+function isString(val) {
+  return is(val, "String");
+}
+function isFunction(val) {
+  return typeof val === "function";
+}
+function isBoolean(val) {
+  return is(val, "Boolean");
+}
+function isRegExp(val) {
+  return is(val, "RegExp");
+}
+function isArray(val) {
+  return !!val && Array.isArray(val);
+}
+function isWindow(val) {
+  return typeof window !== "undefined" && is(val, "Window");
+}
+function isElement(val) {
+  return isObject(val) && !!val.tagName;
+}
+function isMap(val) {
+  return is(val, "Map");
+}
+const isServer = typeof window === "undefined";
+const isClient = !isServer;
+function isUrl(path) {
+  const reg = /^http(s)?:\/\/([\w-]+\.)+[\w-]+(\/[\w- ./?%&=]*)?/;
+  return reg.test(path);
+}
+function isEmptyStr(str) {
+  return str === void 0 || !str && str !== 0 && str !== "0" || !/[^\s]/.test(str + "");
+}
+
+export { is, isArray, isBoolean, isClient, isDate, isDef, isElement, isEmpty, isEmptyStr, isFunction, isMap, isNull, isNullAndUnDef, isNullOrUnDef, isNumber, isObject, isPromise, isRegExp, isServer, isString, isUnDef, isUrl, isWindow };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gct-paas/v-ben",
-  "version": "0.1.4-dev.10",
+  "version": "0.1.4-dev.11",
   "type": "module",
   "description": "paas 平台历史 v-ben 内容",
   "main": "dist/index.min.cjs",
@@ -50,14 +50,16 @@
   "dependencies": {
     "@ant-design/icons-vue": "^6.1.0",
     "@gct-paas/api": "^0.1.1",
-    "@gct-paas/core": "workspace:*",
+    "@gct-paas/core": "0.1.4-dev.11",
     "@gct-paas/platform-icons": "^0.0.2",
-    "@gct-paas/scss": "workspace:*",
+    "@gct-paas/scss": "0.1.4-dev.11",
     "@icon-park/vue-next": "^1.4.2",
     "@vueuse/core": "^14.1.0",
     "ant-design-vue": "3.2.20",
     "lodash-es": "^4.17.23",
-    "vue": "^3.5.29"
+    "sortablejs": "^1.15.7",
+    "vue": "^3.5.29",
+    "vue-types": "^6.0.0"
   },
   "devDependencies": {
     "@gct-paas/build": "^0.1.5-dev.9",
@@ -65,5 +67,6 @@
   },
   "peerDependencies": {
     "vue": "^3.x"
-  }
+  },
+  "gitHead": "6b0fd87c1a7799aa228f40b160e53a7358c25186"
 }