cosey 0.7.4 → 0.7.6

package/components/table/table-export/table-export.js

@@ -1,29 +1,241 @@
-import { formDialogProps } from '../../form-dialog/form-dialog.js';
+import { defineComponent, computed, mergeProps, ref, reactive, createVNode, isVNode } from 'vue';
+import { tableExportEmits, tableExportProps, omittedTableExportProps } from './table-export.api.js';
+import { reactiveOmit } from '@vueuse/core';
+import stdin_default$3 from './list.js';
+import { exportRenderer } from '../table-column/renderer.js';
+import { ElCheckbox, ElMessage } from 'element-plus';
+import stdin_default$2 from '../../form-dialog/form-dialog.js';
+import { Form as _Form, FormItem as _FormItem } from '../../form/index.js';
+import { Panel as _Panel } from '../../panel/index.js';
+import stdin_default$1 from './table-export.style.js';
+import { bookFormats } from '../../../utils/excel/bookFormats.js';
+import { exportExcel } from '../../../utils/excel/index.js';
+import { formatAsBasicDateTime } from '../../../utils/date.js';
+import { useComponentConfig } from '../../config-provider/config-provider.api.js';
+import { useLocale } from '../../../hooks/useLocale.js';
+import { isObject } from '../../../utils/is.js';
+import { useTreeCheck } from '../../../hooks/useTreeCheck.js';
+import { walkTree } from '../../../utils/tree.js';
 
-const tableExportExtraProps = {
-  columns: {
-    type: Array,
-    default: () => []
-  },
-  data: {
-    type: Array,
-    default: () => []
-  },
-  config: {
-    type: [Boolean, Object]
-  },
-  footerCount: {
-    type: Number,
-    default: 0
+function _isSlot(s) {
+  return typeof s === 'function' || Object.prototype.toString.call(s) === '[object Object]' && !isVNode(s);
+}
+var stdin_default = defineComponent({
+  name: "CoTableExport",
+  props: tableExportProps,
+  emits: tableExportEmits,
+  setup(props, {
+    attrs,
+    emit
+  }) {
+    const {
+      prefixCls
+    } = useComponentConfig("table-export");
+    const {
+      hashId
+    } = stdin_default$1(prefixCls);
+    const {
+      t
+    } = useLocale();
+    const mergedProps = computed(() => {
+      return mergeProps(reactiveOmit(props, omittedTableExportProps), attrs);
+    });
+    const filename = computed(() => {
+      return isObject(props.config) ? props.config.filename : "";
+    });
+    const getDefaultFilename = () => {
+      return filename.value || `${t("co.table.export")}-` + formatAsBasicDateTime(/* @__PURE__ */new Date());
+    };
+    const bookTypeOptions = computed(() => bookFormats.map(bookType => {
+      return {
+        label: `${t(bookType.label)} (*${bookType.ext})`,
+        value: bookType.type
+      };
+    }));
+    const mapTypeParamOptions = {
+      csv: [{
+        label: t("co.table.header"),
+        value: "head",
+        checked: true
+      }],
+      txt: [{
+        label: t("co.table.header"),
+        value: "head",
+        checked: true
+      }],
+      xml: [{
+        label: t("co.table.header"),
+        value: "head",
+        checked: true
+      }, {
+        label: t("co.table.groupHeader"),
+        value: "grouping",
+        checked: true
+      }],
+      html: [{
+        label: t("co.table.header"),
+        value: "head",
+        checked: true
+      }, {
+        label: t("co.table.groupHeader"),
+        value: "grouping",
+        checked: true
+      }],
+      xlsx: [{
+        label: t("co.table.header"),
+        value: "head",
+        checked: true
+      }, {
+        label: t("co.table.groupHeader"),
+        value: "grouping",
+        checked: true
+      }]
+    };
+    const paramOptions = ref([]);
+    const paramsFieldProps = computed(() => {
+      return {
+        options: paramOptions.value
+      };
+    });
+    const formModel = reactive({
+      filename: getDefaultFilename(),
+      bookType: "csv",
+      fields: props.columns.map(column => column.prop).filter(Boolean),
+      params: []
+    });
+    const setInitialData = () => {
+      paramOptions.value = mapTypeParamOptions[formModel.bookType];
+      formModel.params = paramOptions.value.filter(option => option.checked).map(option => option.value);
+    };
+    const onBookTypeChange = () => {
+      setInitialData();
+    };
+    const onClosed = () => {
+      setInitialData();
+      formModel.filename = getDefaultFilename();
+    };
+    setInitialData();
+    const {
+      tree,
+      checkAllValue,
+      checkAllIndeterminate,
+      onCheckAllChange,
+      initialize,
+      setCheckedByNode
+    } = useTreeCheck({
+      childrenKey: "columns",
+      initialChecked: true
+    });
+    const setUncheckedIfHiden = () => {
+      walkTree(tree.value, "children", node => {
+        const hidden = !!node.data.hidden;
+        if (hidden) {
+          setCheckedByNode(node, false);
+        }
+      });
+    };
+    const onOpen = () => {
+      initialize(props.columns);
+      setUncheckedIfHiden();
+    };
+    function transformColumns(nodeList = []) {
+      return nodeList.filter(node => node.checkedStatus !== "unchecked").map(({
+        data: column,
+        children
+      }) => {
+        return {
+          ...column,
+          label: column.label || "",
+          prop: column.prop || "",
+          columns: column.columns ? transformColumns(children) : void 0,
+          renderer: column.renderer
+        };
+      });
+    }
+    const getScheme = () => {
+      return {
+        filename: formModel.filename || getDefaultFilename(),
+        bookType: formModel.bookType,
+        worksheet: {
+          name: "sheet",
+          columns: transformColumns(tree.value),
+          noGroup: !formModel.params.includes("grouping"),
+          noHead: !formModel.params.includes("head"),
+          transform: exportRenderer
+        }
+      };
+    };
+    const onSubmit = async () => {
+      await exportExcel(getScheme(), props.data, {
+        footerCount: props.footerCount
+      });
+      ElMessage.success(t("co.common.exportSuccess"));
+    };
+    return () => {
+      return createVNode(stdin_default$2, mergeProps(mergedProps.value, {
+        "width": "fit-content",
+        "onOpen": onOpen,
+        "onClosed": onClosed,
+        "onUpdate:modelValue": value => emit("update:modelValue", value)
+      }), {
+        default: () => [createVNode(_Form, {
+          "model": formModel,
+          "label-width": "auto",
+          "width": "lg",
+          "submit": onSubmit,
+          "class": [hashId.value, prefixCls.value]
+        }, {
+          default: () => [createVNode(_FormItem, {
+            "modelValue": formModel.filename,
+            "onUpdate:modelValue": $event => formModel.filename = $event,
+            "label": t("co.table.filename"),
+            "prop": "filename"
+          }, null), createVNode(_FormItem, {
+            "modelValue": formModel.bookType,
+            "onUpdate:modelValue": $event => formModel.bookType = $event,
+            "label": t("co.table.fileType"),
+            "prop": "bookType",
+            "field-type": "select",
+            "field-props": {
+              options: bookTypeOptions.value,
+              onChange: onBookTypeChange
+            }
+          }, null), createVNode(_FormItem, {
+            "modelValue": formModel.fields,
+            "onUpdate:modelValue": $event => formModel.fields = $event,
+            "label": t("co.table.selectField"),
+            "prop": "fields"
+          }, {
+            default: () => [createVNode(_Panel, {
+              "max-height": "240px"
+            }, {
+              header: () => {
+                let _slot;
+                return createVNode(ElCheckbox, {
+                  "modelValue": checkAllValue.value,
+                  "indeterminate": checkAllIndeterminate.value,
+                  "onChange": onCheckAllChange
+                }, _isSlot(_slot = t("co.common.checkAll")) ? _slot : {
+                  default: () => [_slot]
+                });
+              },
+              default: () => createVNode(stdin_default$3, {
+                "nodeList": tree.value,
+                "style": "--el-checkbox-height: 24px"
+              }, null)
+            })]
+          }), createVNode(_FormItem, {
+            "modelValue": formModel.params,
+            "onUpdate:modelValue": $event => formModel.params = $event,
+            "label": t("co.table.paramConfig"),
+            "prop": "params",
+            "field-type": "checkboxgroup",
+            "field-props": paramsFieldProps.value
+          }, null)]
+        })]
+      });
+    };
   }
-};
-const tableExportProps = {
-  ...formDialogProps,
-  ...tableExportExtraProps
-};
-const omittedTableExportProps = Object.keys(
-  tableExportExtraProps
-);
-const tableExportContextSymbol = Symbol("tableExportContext");
+});
 
-export { omittedTableExportProps, tableExportContextSymbol, tableExportProps };
+export { stdin_default as default };

package/components/table/table-export/{style/index.js → table-export.style.js}

@@ -1,4 +1,4 @@
-import { getSimpleStyleHook } from '../../../theme/getSimpleStyleHook.js';
+import { getSimpleStyleHook } from '../../theme/getSimpleStyleHook.js';
 
 var stdin_default = getSimpleStyleHook("CoTableExport", (token) => {
   const { componentCls } = token;

package/components/table/table-query/table-query.api.d.ts

@@ -0,0 +1,172 @@
+import { type FieldType } from '../../field';
+import { type FormItemProps } from '../../form';
+import { type FormQuerySlots, type FormQueryExpose } from '../../form-query';
+import type { PropType, ExtractPropTypes, VNodeChild, SlotsType } from 'vue';
+export type TableQueryScheme = FormItemProps<FieldType> & {
+    render?: (params: {
+        model: Record<string, any>;
+    }) => VNodeChild;
+    slots?: Record<string, unknown>;
+};
+export declare const tableQueryProps: {
+    schemes: {
+        type: PropType<TableQueryScheme[]>;
+        default: () => never[];
+    };
+    grid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    colProps: {
+        type: PropType<import("../..").ColPublicProps>;
+        default: () => {
+            xs: number;
+            sm: number;
+            md: number;
+            lg: number;
+            xl: number;
+            xxl: number;
+        };
+    };
+    minFields: {
+        type: NumberConstructor;
+        default: number;
+    };
+    collapsed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    width: {
+        type: PropType<import("../..").FormItemWidth>;
+    };
+    rowProps: {
+        type: PropType<import("../..").RowProps>;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    submit: {
+        type: PropType<() => any | Promise<any>>;
+    };
+    reset: {
+        type: PropType<() => any>;
+    };
+    submitText: {
+        type: StringConstructor;
+        default: string;
+    };
+    resetText: {
+        type: StringConstructor;
+        default: string;
+    };
+    submitProps: {
+        type: PropType<import("element-plus").ButtonProps>;
+    };
+    resetProps: {
+        type: PropType<import("element-plus").ButtonProps>;
+    };
+    hideSubmit: {
+        type: BooleanConstructor;
+    };
+    hideReset: {
+        type: BooleanConstructor;
+    };
+    hideButtons: {
+        type: BooleanConstructor;
+    };
+    model: ObjectConstructor;
+    rules: {
+        readonly type: PropType<Partial<Record<string, import("element-plus").FormItemRule | import("element-plus").FormItemRule[]>>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    labelPosition: {
+        readonly type: PropType<"left" | "right" | "top">;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "right";
+    };
+    requireAsteriskPosition: {
+        readonly type: PropType<"left" | "right">;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "left";
+    };
+    labelWidth: {
+        readonly type: PropType<string | number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "";
+    };
+    labelSuffix: {
+        readonly type: PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "";
+    };
+    inline: BooleanConstructor;
+    inlineMessage: BooleanConstructor;
+    statusIcon: BooleanConstructor;
+    showMessage: {
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    validateOnRuleChange: {
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    hideRequiredAsterisk: BooleanConstructor;
+    scrollToError: BooleanConstructor;
+    scrollIntoViewOptions: {
+        readonly type: PropType<boolean | ScrollIntoViewOptions>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    size: {
+        readonly type: PropType<"" | "default" | "large" | "small">;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    disabled: BooleanConstructor;
+};
+export declare const omittedTableQueryProps: keyof typeof tableQueryProps;
+export type TableQueryProps = Partial<ExtractPropTypes<typeof tableQueryProps>>;
+export interface TableQuerySlots extends FormQuerySlots {
+}
+export declare const tableQuerySlots: SlotsType<TableQuerySlots>;
+export declare const tableQueryEmits: {
+    'update:collapsed': (val: boolean) => boolean;
+    validate: (prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => boolean;
+};
+export type TableQueryEmits = typeof tableQueryEmits;
+export interface TableQueryCustomExpose {
+    getFieldsValue: () => Record<string, any>;
+    setFieldsValue: (value: Record<string, any>) => void;
+    getFormModel: () => Record<string, any>;
+}
+export interface TableQueryExpose extends FormQueryExpose, TableQueryCustomExpose {
+}
+export declare const tableQueryExposeKeys: string[];
+export declare function createScheme<T extends FieldType>(props: FormItemProps<T>): FormItemProps<T>;

package/components/table/table-query/table-query.api.js

@@ -0,0 +1,31 @@
+import { formQueryEmits, formQueryProps } from '../../form-query/form-query.api.js';
+import { formExposeKeys } from '../../form/form.api.js';
+
+const tableQueryExtraProps = {
+  schemes: {
+    type: Array,
+    default: () => []
+  }
+};
+const tableQueryProps = {
+  ...formQueryProps,
+  ...tableQueryExtraProps
+};
+const omittedTableQueryProps = Object.keys(
+  tableQueryExtraProps
+);
+const tableQuerySlots = Object;
+const tableQueryEmits = {
+  ...formQueryEmits
+};
+const tableQueryExposeKeys = [
+  ...formExposeKeys,
+  "getFieldsValue",
+  "setFieldsValue",
+  "getFormModel"
+];
+function createScheme(props) {
+  return props;
+}
+
+export { createScheme, omittedTableQueryProps, tableQueryEmits, tableQueryExposeKeys, tableQueryProps, tableQuerySlots };