cosey 0.7.4 → 0.7.6

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

@@ -1,16 +1,6 @@
-import { type FieldType } from '../../field';
-import { type FormItemProps } from '../../form';
-import { type FormQuerySlots, type FormQueryEmits, type FormQueryExpose } from '../../form-query';
-import { type PropType, type ExtractPropTypes, VNodeChild } from 'vue';
-export type TableQueryScheme = FormItemProps<FieldType> & {
-    render?: (params: {
-        model: Record<string, any>;
-    }) => VNodeChild;
-    slots?: Record<string, unknown>;
-};
-export declare const tableQueryProps: {
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     schemes: {
-        type: PropType<TableQueryScheme[]>;
+        type: import("vue").PropType<import("./table-query.api").TableQueryScheme[]>;
         default: () => never[];
     };
     grid: {
@@ -18,7 +8,7 @@ export declare const tableQueryProps: {
         default: boolean;
     };
     colProps: {
-        type: PropType<import("../..").ColPublicProps>;
+        type: import("vue").PropType<import("../..").ColPublicProps>;
         default: () => {
             xs: number;
             sm: number;
@@ -37,20 +27,20 @@ export declare const tableQueryProps: {
         default: boolean;
     };
     width: {
-        type: PropType<import("../..").FormItemWidth>;
+        type: import("vue").PropType<import("../..").FormItemWidth>;
     };
     rowProps: {
-        type: PropType<import("../..").RowProps>;
+        type: import("vue").PropType<import("../..").RowProps>;
     };
     readonly: {
         type: BooleanConstructor;
         default: boolean;
     };
     submit: {
-        type: PropType<() => any | Promise<any>>;
+        type: import("vue").PropType<() => any | Promise<any>>;
     };
     reset: {
-        type: PropType<() => any>;
+        type: import("vue").PropType<() => any>;
     };
     submitText: {
         type: StringConstructor;
@@ -61,10 +51,10 @@ export declare const tableQueryProps: {
         default: string;
     };
     submitProps: {
-        type: PropType<import("element-plus").ButtonProps>;
+        type: import("vue").PropType<import("element-plus").ButtonProps>;
     };
     resetProps: {
-        type: PropType<import("element-plus").ButtonProps>;
+        type: import("vue").PropType<import("element-plus").ButtonProps>;
     };
     hideSubmit: {
         type: BooleanConstructor;
@@ -77,13 +67,13 @@ export declare const tableQueryProps: {
     };
     model: ObjectConstructor;
     rules: {
-        readonly type: PropType<Partial<Record<string, import("element-plus").FormItemRule | import("element-plus").FormItemRule[]>>>;
+        readonly type: import("vue").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 type: import("vue").PropType<"left" | "right" | "top">;
         readonly required: false;
         readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
@@ -91,7 +81,7 @@ export declare const tableQueryProps: {
         readonly default: "right";
     };
     requireAsteriskPosition: {
-        readonly type: PropType<"left" | "right">;
+        readonly type: import("vue").PropType<"left" | "right">;
         readonly required: false;
         readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
@@ -99,7 +89,7 @@ export declare const tableQueryProps: {
         readonly default: "left";
     };
     labelWidth: {
-        readonly type: PropType<string | number>;
+        readonly type: import("vue").PropType<string | number>;
         readonly required: false;
         readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
@@ -107,7 +97,7 @@ export declare const tableQueryProps: {
         readonly default: "";
     };
     labelSuffix: {
-        readonly type: PropType<string>;
+        readonly type: import("vue").PropType<string>;
         readonly required: false;
         readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
@@ -118,7 +108,7 @@ export declare const tableQueryProps: {
     inlineMessage: BooleanConstructor;
     statusIcon: BooleanConstructor;
     showMessage: {
-        readonly type: PropType<boolean>;
+        readonly type: import("vue").PropType<boolean>;
         readonly required: false;
         readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
@@ -126,7 +116,7 @@ export declare const tableQueryProps: {
         readonly default: true;
     };
     validateOnRuleChange: {
-        readonly type: PropType<boolean>;
+        readonly type: import("vue").PropType<boolean>;
         readonly required: false;
         readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
@@ -136,7 +126,7 @@ export declare const tableQueryProps: {
     hideRequiredAsterisk: BooleanConstructor;
     scrollToError: BooleanConstructor;
     scrollIntoViewOptions: {
-        readonly type: PropType<boolean | ScrollIntoViewOptions>;
+        readonly type: import("vue").PropType<boolean | ScrollIntoViewOptions>;
         readonly required: false;
         readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
@@ -144,25 +134,198 @@ export declare const tableQueryProps: {
         readonly default: true;
     };
     size: {
-        readonly type: PropType<"" | "default" | "large" | "small">;
+        readonly type: import("vue").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 interface TableQueryEmits extends /* @vue-ignore */ FormQueryEmits {
-}
-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>;
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    'update:collapsed': (val: boolean) => boolean;
+    validate: (prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => boolean;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    schemes: {
+        type: import("vue").PropType<import("./table-query.api").TableQueryScheme[]>;
+        default: () => never[];
+    };
+    grid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    colProps: {
+        type: import("vue").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: import("vue").PropType<import("../..").FormItemWidth>;
+    };
+    rowProps: {
+        type: import("vue").PropType<import("../..").RowProps>;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    submit: {
+        type: import("vue").PropType<() => any | Promise<any>>;
+    };
+    reset: {
+        type: import("vue").PropType<() => any>;
+    };
+    submitText: {
+        type: StringConstructor;
+        default: string;
+    };
+    resetText: {
+        type: StringConstructor;
+        default: string;
+    };
+    submitProps: {
+        type: import("vue").PropType<import("element-plus").ButtonProps>;
+    };
+    resetProps: {
+        type: import("vue").PropType<import("element-plus").ButtonProps>;
+    };
+    hideSubmit: {
+        type: BooleanConstructor;
+    };
+    hideReset: {
+        type: BooleanConstructor;
+    };
+    hideButtons: {
+        type: BooleanConstructor;
+    };
+    model: ObjectConstructor;
+    rules: {
+        readonly type: import("vue").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: import("vue").PropType<"left" | "right" | "top">;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "right";
+    };
+    requireAsteriskPosition: {
+        readonly type: import("vue").PropType<"left" | "right">;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "left";
+    };
+    labelWidth: {
+        readonly type: import("vue").PropType<string | number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "";
+    };
+    labelSuffix: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "";
+    };
+    inline: BooleanConstructor;
+    inlineMessage: BooleanConstructor;
+    statusIcon: BooleanConstructor;
+    showMessage: {
+        readonly type: import("vue").PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    validateOnRuleChange: {
+        readonly type: import("vue").PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    hideRequiredAsterisk: BooleanConstructor;
+    scrollToError: BooleanConstructor;
+    scrollIntoViewOptions: {
+        readonly type: import("vue").PropType<boolean | ScrollIntoViewOptions>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    size: {
+        readonly type: import("vue").PropType<"" | "default" | "large" | "small">;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    disabled: BooleanConstructor;
+}>> & Readonly<{
+    onValidate?: ((prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => any) | undefined;
+    "onUpdate:collapsed"?: ((val: boolean) => any) | undefined;
+}>, {
+    grid: boolean;
+    inline: boolean;
+    disabled: boolean;
+    readonly: boolean;
+    labelWidth: string | number;
+    labelPosition: "left" | "right" | "top";
+    inlineMessage: boolean;
+    showMessage: boolean;
+    schemes: import("./table-query.api").TableQueryScheme[];
+    colProps: {
+        push?: number | undefined;
+        offset?: number | undefined;
+        span?: number | undefined;
+        sm?: import("../..").ColSize | undefined;
+        md?: import("../..").ColSize | undefined;
+        lg?: import("../..").ColSize | undefined;
+        xl?: import("../..").ColSize | undefined;
+        tag?: string | undefined;
+        xs?: import("../..").ColSize | undefined;
+        pull?: number | undefined;
+        xxl?: import("../..").ColSize | undefined;
+    };
+    minFields: number;
+    collapsed: boolean;
+    submitText: string;
+    resetText: string;
+    hideSubmit: boolean;
+    hideReset: boolean;
+    hideButtons: boolean;
+    requireAsteriskPosition: "left" | "right";
+    labelSuffix: string;
+    statusIcon: boolean;
+    validateOnRuleChange: boolean;
+    hideRequiredAsterisk: boolean;
+    scrollToError: boolean;
+    scrollIntoViewOptions: boolean | ScrollIntoViewOptions;
+}, import("vue").SlotsType<import("./table-query.api").TableQuerySlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

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

@@ -1,27 +1,87 @@
-import { formQueryProps } from '../../form-query/form-query.api.js';
-import { formExposeKeys } from '../../form/form.api.js';
+import { defineComponent, ref, reactive, computed, onBeforeMount, unref, h } from 'vue';
+import { tableQueryEmits, tableQuerySlots, tableQueryProps, omittedTableQueryProps, tableQueryExposeKeys } from './table-query.api.js';
+import { reactiveOmit } from '@vueuse/core';
+import { cloneDeep } from 'lodash-es';
+import { FormItem as _FormItem } from '../../form/index.js';
+import { FormQuery as _FormQuery } from '../../form-query/index.js';
+import { createMergedExpose } from '../../../utils/vue.js';
 
-const tableQueryExtraProps = {
-  schemes: {
-    type: Array,
-    default: () => []
+var stdin_default = defineComponent({
+  name: "CoTableQuery",
+  props: tableQueryProps,
+  slots: tableQuerySlots,
+  emits: tableQueryEmits,
+  setup(props, {
+    expose
+  }) {
+    const formQueryProps = reactiveOmit(props, omittedTableQueryProps);
+    const formQueryRef = ref();
+    const defaultModel = reactive({});
+    const formModel = computed(() => {
+      return props.model || defaultModel;
+    });
+    onBeforeMount(() => {
+      props.schemes.forEach(item => {
+        unref(formModel)[item.prop] = item.modelValue;
+      });
+    });
+    const onEnter = () => {
+      formQueryRef.value?.submit();
+    };
+    const customExpose = {
+      getFieldsValue() {
+        return cloneDeep(unref(formModel));
+      },
+      setFieldsValue(value) {
+        Object.assign(unref(formModel), value);
+      },
+      getFormModel() {
+        return unref(formModel);
+      }
+    };
+    expose(createMergedExpose(tableQueryExposeKeys, () => formQueryRef.value, customExpose));
+    return () => {
+      return h(_FormQuery, {
+        ...formQueryProps,
+        ref: formQueryRef,
+        model: unref(formModel),
+        onKeyup: event => {
+          if (event.key === "Enter") {
+            event.preventDefault();
+            onEnter();
+          }
+        },
+        onKeydown: event => {
+          if (event.key === "Enter") {
+            event.preventDefault();
+          }
+        }
+      }, () => {
+        return props.schemes.map(item => {
+          const {
+            slots,
+            render,
+            ...rest
+          } = item;
+          if (render) {
+            return h(_FormItem, rest, {
+              ...slots,
+              default: () => {
+                return render({
+                  model: unref(formModel)
+                });
+              }
+            });
+          }
+          return h(_FormItem, {
+            ...rest,
+            modelValue: unref(formModel)[rest.prop],
+            "onUpdate:modelValue": value => unref(formModel)[rest.prop] = value
+          }, slots);
+        });
+      });
+    };
   }
-};
-const tableQueryProps = {
-  ...formQueryProps,
-  ...tableQueryExtraProps
-};
-const omittedTableQueryProps = Object.keys(
-  tableQueryExtraProps
-);
-const tableQueryExposeKeys = [
-  ...formExposeKeys,
-  "getFieldsValue",
-  "setFieldsValue",
-  "getFormModel"
-];
-function createScheme(props) {
-  return props;
-}
+});
 
-export { createScheme, omittedTableQueryProps, tableQueryExposeKeys, tableQueryProps };
+export { stdin_default as default };

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

@@ -0,0 +1,17 @@
+import type { ExtractPropTypes, PropType, VNodeChild } from 'vue';
+export interface TableStatisticsColumn {
+    label: VNodeChild;
+    prop: string;
+    format?: (value: any) => any;
+}
+export declare const tableStatisticsProps: {
+    columns: {
+        type: PropType<TableStatisticsColumn[]>;
+        default: () => never[];
+    };
+    data: {
+        type: PropType<Record<string, any>>;
+        default: () => {};
+    };
+};
+export type TableStatisticsProps = ExtractPropTypes<typeof tableStatisticsProps>;

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

@@ -0,0 +1,12 @@
+const tableStatisticsProps = {
+  columns: {
+    type: Array,
+    default: () => []
+  },
+  data: {
+    type: Object,
+    default: () => ({})
+  }
+};
+
+export { tableStatisticsProps };

package/components/table/table-stats/table-stats.d.ts

@@ -1,14 +1,23 @@
-import { VNodeChild } from 'vue';
-export interface TableStatisticsColumn {
-    label: VNodeChild;
-    prop: string;
-    format?: (value: unknown) => unknown;
-}
-export interface TableStatisticsProps {
-    columns?: TableStatisticsColumn[];
-    data?: Record<string, unknown>;
-}
-export declare const defaultTableStatsProps: {
-    columns: () => never[];
-    data: () => {};
-};
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    columns: {
+        type: import("vue").PropType<import("./table-stats.api").TableStatisticsColumn[]>;
+        default: () => never[];
+    };
+    data: {
+        type: import("vue").PropType<Record<string, any>>;
+        default: () => {};
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    columns: {
+        type: import("vue").PropType<import("./table-stats.api").TableStatisticsColumn[]>;
+        default: () => never[];
+    };
+    data: {
+        type: import("vue").PropType<Record<string, any>>;
+        default: () => {};
+    };
+}>> & Readonly<{}>, {
+    columns: import("./table-stats.api").TableStatisticsColumn[];
+    data: Record<string, any>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/components/table/table-stats/table-stats.js

@@ -1,6 +1,38 @@
-const defaultTableStatsProps = {
-  columns: () => [],
-  data: () => ({})
-};
+import { defineComponent, createVNode, createTextVNode } from 'vue';
+import { tableStatisticsProps } from './table-stats.api.js';
+import stdin_default$1 from './table-stats.style.js';
+import { useComponentConfig } from '../../config-provider/config-provider.api.js';
 
-export { defaultTableStatsProps };
+var stdin_default = defineComponent({
+  name: "CoTableStats",
+  props: tableStatisticsProps,
+  setup(props) {
+    const {
+      prefixCls
+    } = useComponentConfig("table-stats");
+    const {
+      hashId
+    } = stdin_default$1(prefixCls);
+    return () => {
+      return createVNode("div", {
+        "class": [hashId.value, prefixCls.value]
+      }, [props.columns.map(column => {
+        let value = props.data[column.prop];
+        if (column.format) {
+          value = column.format(value);
+        }
+        return createVNode("div", {
+          "class": `${prefixCls.value}-column`
+        }, [createVNode("div", {
+          "class": `${prefixCls.value}-label`
+        }, [column.label]), createVNode("div", {
+          "class": `${prefixCls.value}-colon`
+        }, [createTextVNode(":")]), createVNode("div", {
+          "class": `${prefixCls.value}-value`
+        }, [value])]);
+      })]);
+    };
+  }
+});
+
+export { stdin_default as default };

package/components/table/table.d.ts

@@ -1,8 +1,8 @@
 import { TableColumnCtx, type PaginationProps } from 'element-plus';
 import { type PropType, type ExtractPropTypes, MaybeRef } from 'vue';
 import { type MayBeTableColumnProps } from './table-column/table-column.api';
-import { TableQueryExpose, type TableQueryProps } from './table-query/table-query';
-import { TableStatisticsColumn } from './table-stats/table-stats';
+import { TableQueryExpose, type TableQueryProps } from './table-query/table-query.api';
+import { TableStatisticsColumn } from './table-stats/table-stats.api';
 export interface ToolbarConfig {
     reload?: boolean;
     export?: boolean | {

package/components/table/table.js

@@ -1,6 +1,6 @@
 import elTableProps from 'element-plus/es/components/table/src/table/defaults.mjs';
 import { upperFirst, camelCase, omit } from 'lodash-es';
-import { tableQueryExposeKeys } from './table-query/table-query.js';
+import { tableQueryExposeKeys } from './table-query/table-query.api.js';
 
 const tableEmitEvents = [
   "select-all",

package/components/table/table.vue.d.ts

@@ -43,7 +43,7 @@ declare const __VLS_component: import("vue").DefineComponent<import("vue").Extra
         type: import("vue").PropType<import("./table").TableConfig["keys"]>;
     };
     statsColumns: {
-        type: import("vue").PropType<import("vue").MaybeRef<import("./table-stats/table-stats").TableStatisticsColumn[]>>;
+        type: import("vue").PropType<import("vue").MaybeRef<import("./table-stats/table-stats.api").TableStatisticsColumn[]>>;
     };
     statsData: {
         type: import("vue").MaybeRef<any>;
@@ -214,7 +214,7 @@ declare const __VLS_component: import("vue").DefineComponent<import("vue").Extra
         type: import("vue").PropType<import("./table").TableConfig["keys"]>;
     };
     statsColumns: {
-        type: import("vue").PropType<import("vue").MaybeRef<import("./table-stats/table-stats").TableStatisticsColumn[]>>;
+        type: import("vue").PropType<import("vue").MaybeRef<import("./table-stats/table-stats.api").TableStatisticsColumn[]>>;
     };
     statsData: {
         type: import("vue").MaybeRef<any>;