cnhis-design-vue 3.1.24-beta.7 → 3.1.24-beta.8

package/es/components/big-table/src/components/edit-form/edit-separate.vue.d.ts

@@ -0,0 +1,130 @@
+import { AnyObject } from '../../../../../../es/shared/types';
+import { CSSProperties, PropType } from 'vue';
+declare const _default: import("vue").DefineComponent<{
+    col: {
+        type: PropType<AnyObject>;
+        required: true;
+    };
+    row: {
+        type: PropType<AnyObject>;
+        required: true;
+    };
+    index: {
+        type: NumberConstructor;
+        required: true;
+    };
+}, {
+    props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+        col: {
+            type: PropType<AnyObject>;
+            required: true;
+        };
+        row: {
+            type: PropType<AnyObject>;
+            required: true;
+        };
+        index: {
+            type: NumberConstructor;
+            required: true;
+        };
+    }>> & {
+        onFormChange?: ((...args: any[]) => any) | undefined;
+    }>>;
+    popoverRef: import("vue").Ref<any>;
+    show: import("vue").Ref<boolean>;
+    setShow: (v: boolean) => void;
+    emit: (event: "formChange", ...args: any[]) => void;
+    editContent: import("vue").Ref<any>;
+    getRowData: (row: AnyObject) => {
+        separateData: Record<string, string>;
+        index: number;
+        rawRow: AnyObject;
+        row: AnyObject;
+    } | undefined;
+    onShow: (target: {
+        separateData: Record<string, string>;
+        index: number;
+        rawRow: AnyObject;
+        row: AnyObject;
+    } | undefined) => Promise<void>;
+    onClose: (target: {
+        separateData: Record<string, string>;
+        index: number;
+        rawRow: AnyObject;
+        row: AnyObject;
+    } | undefined) => Promise<void>;
+    updateShow: (show: boolean) => void;
+    style: CSSProperties;
+    SlotRender: import("vue").DefineComponent<{
+        renderer: {
+            type: PropType<string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions> | import("../../../../../../es/shared/types").Func<any[], any>>;
+            required: true;
+        };
+        rootSlots: {
+            type: PropType<Record<string, import("../../../../../../es/shared/types").Func<any[], any>>>;
+        };
+    }, () => any, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        renderer: {
+            type: PropType<string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions> | import("../../../../../../es/shared/types").Func<any[], any>>;
+            required: true;
+        };
+        rootSlots: {
+            type: PropType<Record<string, import("../../../../../../es/shared/types").Func<any[], any>>>;
+        };
+    }>>, {}>;
+    NPopover: any;
+    NInput: any;
+    Separate: import("vue").DefineComponent<{
+        col: {
+            type: PropType<AnyObject>;
+            required: true;
+        };
+        row: {
+            type: PropType<AnyObject>;
+            required: true;
+        };
+    }, {
+        props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+            col: {
+                type: PropType<AnyObject>;
+                required: true;
+            };
+            row: {
+                type: PropType<AnyObject>;
+                required: true;
+            };
+        }>> & {}>>;
+        separateDataMap: import("vue").Ref<WeakMap<AnyObject, {
+            separateData: Record<string, string>;
+            index: number;
+            rawRow: AnyObject;
+            row: AnyObject;
+        }>>;
+        displayContent: import("vue").ComputedRef<string>;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        col: {
+            type: PropType<AnyObject>;
+            required: true;
+        };
+        row: {
+            type: PropType<AnyObject>;
+            required: true;
+        };
+    }>>, {}>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "formChange"[], "formChange", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    col: {
+        type: PropType<AnyObject>;
+        required: true;
+    };
+    row: {
+        type: PropType<AnyObject>;
+        required: true;
+    };
+    index: {
+        type: NumberConstructor;
+        required: true;
+    };
+}>> & {
+    onFormChange?: ((...args: any[]) => any) | undefined;
+}, {}>;
+export default _default;

package/es/components/big-table/src/components/edit-form/edit-time.d.ts

@@ -0,0 +1,43 @@
+declare const _default: import("vue").DefineComponent<{
+    type: {
+        type: StringConstructor;
+        default: string;
+    };
+    col: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    row: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    index: {
+        type: (NumberConstructor | ObjectConstructor)[];
+        default: number;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "formChange"[], "formChange", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    type: {
+        type: StringConstructor;
+        default: string;
+    };
+    col: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    row: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    index: {
+        type: (NumberConstructor | ObjectConstructor)[];
+        default: number;
+    };
+}>> & {
+    onFormChange?: ((...args: any[]) => any) | undefined;
+}, {
+    type: string;
+    row: Record<string, any>;
+    index: number | Record<string, any>;
+    col: Record<string, any>;
+}>;
+export default _default;

package/es/components/big-table/src/components/edit-form/edit-time.js

@@ -0,0 +1,62 @@
+import { defineComponent, createVNode, mergeProps } from 'vue';
+import { NTimePicker } from 'naive-ui';
+import { useCommon } from './useCommon.js';
+
+var EditTime = defineComponent({
+  name: "EditTime",
+  inheritAttrs: false,
+  components: {
+    NTimePicker
+  },
+  props: {
+    type: {
+      type: String,
+      default: "input"
+    },
+    col: {
+      type: Object,
+      default: () => ({})
+    },
+    row: {
+      type: Object,
+      default: () => ({})
+    },
+    index: {
+      type: [Number, Object],
+      default: 0
+    }
+  },
+  emits: ["formChange"],
+  setup(props, {
+    attrs,
+    emit
+  }) {
+    const {
+      formRef,
+      isShow
+    } = useCommon(props, attrs);
+    const onUpdateValue = (value) => {
+      emit("formChange", {
+        value,
+        row: props.row,
+        column: props.col,
+        index: props.index
+      });
+    };
+    const config = {
+      placeholder: props.col.placeholder || "\u8BF7\u9009\u62E9",
+      valueFormat: props.col.valueFormat || "HH:mm",
+      format: props.col.valueFormat || "yyyy-MM-dd HH:mm:ss",
+      ...props.col.componentProps || {}
+    };
+    return () => createVNode(NTimePicker, mergeProps({
+      "ref": formRef,
+      "show": isShow.value,
+      "onUpdate:show": ($event) => isShow.value = $event
+    }, attrs, config, {
+      "onUpdateFormattedValue": onUpdateValue
+    }), null);
+  }
+});
+
+export { EditTime as default };

package/es/components/big-table/src/components/edit-form/useCommon.d.ts

@@ -0,0 +1,4 @@
+export declare const useCommon: (props: any, attrs: any) => {
+    formRef: import("vue").Ref<HTMLElement | null>;
+    isShow: import("vue").Ref<boolean>;
+};

package/es/components/big-table/src/components/edit-form/useCommon.js

@@ -0,0 +1,19 @@
+import { ref, onMounted } from 'vue';
+
+const useCommon = (props, attrs) => {
+  const formRef = ref(null);
+  const isShow = ref(false);
+  onMounted(() => {
+    var _a;
+    if (attrs.editTrigger !== "manual") {
+      (_a = formRef.value) == null ? void 0 : _a.focus();
+      isShow.value = true;
+    }
+  });
+  return {
+    formRef,
+    isShow
+  };
+};
+
+export { useCommon };

package/es/components/big-table/src/components/input-button.js

@@ -0,0 +1,34 @@
+import { defineComponent, ref, openBlock, createBlock, unref, withCtx, createVNode, createTextVNode } from 'vue';
+import { NInput, NButton } from 'naive-ui';
+import _export_sfc from '../../../../_virtual/plugin-vue_export-helper.js';
+
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "input-button",
+  setup(__props) {
+    const content = ref("");
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(NInput), {
+        value: content.value,
+        "onUpdate:value": _cache[1] || (_cache[1] = ($event) => content.value = $event),
+        placeholder: "\u5B57\u6BB5\u641C\u7D22",
+        class: "check-seach-input"
+      }, {
+        suffix: withCtx(() => [
+          createVNode(unref(NButton), {
+            text: "",
+            onClick: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("trigger", content.value))
+          }, {
+            default: withCtx(() => [
+              createTextVNode("\u641C\u7D22")
+            ]),
+            _: 1
+          })
+        ]),
+        _: 1
+      }, 8, ["value"]);
+    };
+  }
+});
+var InputButtonScript = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "input-button.vue"]]);
+
+export { InputButtonScript as default };

package/es/components/big-table/src/components/input-button.vue.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("vue").DefineComponent<{}, {
+    content: import("vue").Ref<string>;
+    NButton: any;
+    NInput: any;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+export default _default;

package/es/components/big-table/src/components/separate.js

@@ -0,0 +1,30 @@
+import { defineComponent, computed, openBlock, createElementBlock, createTextVNode, toDisplayString, unref, createElementVNode } from 'vue';
+import { useSeparateMap } from '../hooks/useSeparateRow.js';
+import _export_sfc from '../../../../_virtual/plugin-vue_export-helper.js';
+
+const _hoisted_1 = { class: "big-table__separate" };
+const _hoisted_2 = /* @__PURE__ */ createElementVNode("span", { class: "big-table__separatePlaceholder" }, /* @__PURE__ */ toDisplayString(` `), -1);
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "separate",
+  props: {
+    col: { type: Object, required: true },
+    row: { type: Object, required: true }
+  },
+  setup(__props) {
+    const props = __props;
+    const { separateDataMap } = useSeparateMap();
+    const displayContent = computed(() => {
+      const target = separateDataMap.value.get(props.row);
+      return target ? target.separateData[props.col.field] : "";
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        createTextVNode(toDisplayString(unref(displayContent)) + " ", 1),
+        _hoisted_2
+      ]);
+    };
+  }
+});
+var Separate = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "separate.vue"]]);
+
+export { Separate as default };

package/es/components/big-table/src/components/separate.vue.d.ts

@@ -0,0 +1,40 @@
+import { AnyObject } from '../../../../../es/shared/types';
+import { PropType } from 'vue';
+declare const _default: import("vue").DefineComponent<{
+    col: {
+        type: PropType<AnyObject>;
+        required: true;
+    };
+    row: {
+        type: PropType<AnyObject>;
+        required: true;
+    };
+}, {
+    props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+        col: {
+            type: PropType<AnyObject>;
+            required: true;
+        };
+        row: {
+            type: PropType<AnyObject>;
+            required: true;
+        };
+    }>> & {}>>;
+    separateDataMap: import("vue").Ref<WeakMap<AnyObject, {
+        separateData: Record<string, string>;
+        index: number;
+        rawRow: AnyObject;
+        row: AnyObject;
+    }>>;
+    displayContent: import("vue").ComputedRef<string>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    col: {
+        type: PropType<AnyObject>;
+        required: true;
+    };
+    row: {
+        type: PropType<AnyObject>;
+        required: true;
+    };
+}>>, {}>;
+export default _default;

package/es/components/big-table/src/constants/index.d.ts

@@ -0,0 +1,3 @@
+import { InjectionKey } from 'vue';
+import { SeparateHandle } from '../../../../../es/components/big-table/src/hooks/useSeparateRow';
+export declare const InjectionSeparateHandle: InjectionKey<SeparateHandle>;

package/es/components/big-table/src/constants/index.js

@@ -0,0 +1,3 @@
+const InjectionSeparateHandle = Symbol("InjectionSeparateHandle");
+
+export { InjectionSeparateHandle };

package/es/components/big-table/src/hooks/export.d.ts

@@ -0,0 +1 @@
+export * from './useColumnConfigAdaptor';

package/es/components/big-table/src/hooks/export.js

@@ -0,0 +1 @@
+export { useColumnConfigAdaptor } from './useColumnConfigAdaptor.js';

package/es/components/big-table/src/hooks/index.d.ts

@@ -0,0 +1,9 @@
+export * from './useAnchor';
+export * from './useEdit';
+export * from './useFormat';
+export * from './useTableParse';
+export * from './useBatchEditing';
+export * from './useNestTable';
+export * from './useEvent';
+export * from './useAnnotation';
+export * from './useSeparateRow';

package/es/components/big-table/src/hooks/index.js

@@ -0,0 +1,9 @@
+export { useAnchor } from './useAnchor.js';
+export { comps, useEdit } from './useEdit.js';
+export { useFormat } from './useFormat.js';
+export { useTableParse } from './useTableParse.js';
+export { useBatchEditing } from './useBatchEditing.js';
+export { useNestTable } from './useNestTable.js';
+export { useEvent } from './useEvent.js';
+export { useAnnotation } from './useAnnotation.js';
+export { SeparateHandle, useSeparateMap, useSeparateRow } from './useSeparateRow.js';

package/es/components/big-table/src/hooks/useAnchor.d.ts

@@ -0,0 +1,7 @@
+export declare const useAnchor: (props: any, state: any, emit: any, xGrid: any) => {
+    initAnchor: () => void;
+    updateAnchor: (field: string) => Promise<void>;
+    anchorEvent: ({ scrollLeft }: {
+        scrollLeft: number;
+    }) => void;
+};

package/es/components/big-table/src/hooks/useAnchor.js

@@ -0,0 +1,49 @@
+import { useThrottleFn } from '@vueuse/core';
+
+const useAnchor = (props, state, emit, xGrid) => {
+  let setAnchorStatus = true;
+  function initAnchor() {
+    var _a, _b, _c;
+    if ((_a = props.anchor) == null ? void 0 : _a.length) {
+      const columns = xGrid.value.getColumns();
+      let left = 0;
+      columns.forEach((column) => {
+        const { field, minWidth, width, fixed } = column;
+        const colWidth = +(minWidth || width);
+        if (fixed == "left") ; else {
+          left += colWidth;
+          const anchorObj = props.anchor.find((v) => v.field === field);
+          anchorObj && state.anchorList.push({
+            ...anchorObj,
+            left: left - colWidth
+          });
+        }
+      });
+      state.anchorValue = ((_c = (_b = state.anchorList) == null ? void 0 : _b[0]) == null ? void 0 : _c.field) || "";
+    }
+  }
+  async function updateAnchor(field) {
+    setAnchorStatus = false;
+    const anchorObj = state.anchorList.find((v) => v.field === field);
+    await xGrid.value.scrollTo(anchorObj.left);
+    setTimeout(() => {
+      setAnchorStatus = true;
+    });
+  }
+  function setAnchorValue({ scrollLeft }) {
+    if (state.anchorList.length && setAnchorStatus) {
+      const anchorObj = state.anchorList.find((v) => scrollLeft < v.left);
+      if (anchorObj) {
+        state.anchorValue = anchorObj.field;
+      }
+    }
+  }
+  const anchorEvent = useThrottleFn(setAnchorValue, 800);
+  return {
+    initAnchor,
+    updateAnchor,
+    anchorEvent
+  };
+};
+
+export { useAnchor };

package/es/components/big-table/src/hooks/useAnnotation.d.ts

@@ -0,0 +1,4 @@
+import { AnyObject } from '../../../../../es/shared/types';
+export declare function useAnnotation(props: AnyObject): {
+    renderAnnotation: (columnConfig: AnyObject) => JSX.Element | null;
+};

package/es/components/big-table/src/hooks/useAnnotation.js

@@ -0,0 +1,21 @@
+import { createVNode } from 'vue';
+import { isObject } from '@vue/shared';
+import Annotation from '../../../annotation-edit/index.js';
+
+function useAnnotation(props) {
+  function renderAnnotation(columnConfig) {
+    if (!isObject(props.annotation) || columnConfig.annotation === false)
+      return null;
+    return createVNode("section", {
+      "class": "big-table__annotationWrapper"
+    }, [createVNode(Annotation, {
+      "modelValue": props.annotation[columnConfig.columnName],
+      "onUpdate:modelValue": ($event) => props.annotation[columnConfig.columnName] = $event
+    }, null)]);
+  }
+  return {
+    renderAnnotation
+  };
+}
+
+export { useAnnotation };

package/es/components/big-table/src/hooks/useBatchEditing.d.ts

@@ -0,0 +1,17 @@
+export declare const useBatchEditing: (props: any, state: any, emit: any, xGrid: any) => {
+    allSelectedLength: import("vue").ComputedRef<any>;
+    checkOperateCurrentTable: () => boolean;
+    setRowStatus: (vxeTable: any, rowIndex: number, value: any) => false | undefined;
+    resetBatchOperationRowStatus: () => false | undefined;
+    checkListFormUnionSettingParamsList: () => boolean;
+    handleClickCancelBtnByInline: () => Promise<void>;
+    setAllRowInlineStatus: (disabled?: boolean) => void;
+    hideSelectCloumns: () => void;
+    handleEditFormLength: () => number | undefined;
+    getInlineOpreateRow: () => {
+        row: any;
+        rowIndex: any;
+    };
+    resetOperationRowStatus: () => false | undefined;
+    recordClickBtnInfo: (row?: any, index?: number) => void;
+};