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

package/es/components/form-render/src/components/renderer/levelSearchCascade.js

@@ -0,0 +1,279 @@
+import { defineComponent, computed, ref, inject, watch, createVNode } from 'vue';
+import { isEqual, isString, isEmpty, isFunction, omit } from 'lodash-es';
+import '../../../index.js';
+import { InjectAsyncQueue } from '../../constants/index.js';
+import { useCommonInjection } from '../../hooks/useCommonInjection.js';
+import { formRenderLog } from '../../utils/index.js';
+import { connect, mapProps } from '@formily/vue';
+import SearchCascader from '../../../../search-cascader/index.js';
+import script$1 from '../../../../../shared/components/no-data/NoData.js';
+import { visitedDecorator, assignUpdateValue } from '../../utils/schema.js';
+import { useFormField } from '../../hooks/useFormField.js';
+import { useFormRequest } from '../../hooks/useFormRequest.js';
+
+const script = defineComponent({
+  name: "FormSearchCascade",
+  props: {
+    options: {
+      type: Array,
+      default: () => []
+    },
+    onFocus: {
+      type: Function
+    },
+    autograph: {
+      type: String,
+      required: true
+    },
+    lazyRequest: {
+      type: Boolean,
+      default: true
+    },
+    requestCache: {
+      type: Boolean,
+      default: true
+    },
+    wordbook: {
+      type: Object,
+      required: true
+    },
+    onChange: {},
+    value: {
+      type: [String, Array]
+    }
+  },
+  emits: ["update:value"],
+  setup(props, {
+    emit
+  }) {
+    const valueRef = computed({
+      get: () => props.value,
+      set: (v) => emit("update:value", v)
+    });
+    const showRef = ref(false);
+    const optionsRef = ref([]);
+    const {
+      field,
+      fieldKey
+    } = useFormField();
+    const labelKey = computed(() => {
+      var _a, _b, _c;
+      return (_c = (_b = (_a = props.wordbook) == null ? void 0 : _a.render_key) == null ? void 0 : _b[0]) != null ? _c : "text";
+    });
+    const valueKey = computed(() => {
+      var _a, _b;
+      return (_b = (_a = props.wordbook) == null ? void 0 : _a.value_key) != null ? _b : "value";
+    });
+    const depth = computed(() => {
+      var _a;
+      return ((_a = props.wordbook) == null ? void 0 : _a.level_num) || Infinity;
+    });
+    const asyncQueue = inject(InjectAsyncQueue);
+    const {
+      getSearchRequestInfo
+    } = useFormRequest();
+    async function fetchData(node, keyword) {
+      try {
+        if (node && !node.__keyword && node.isLeaf) {
+          return updateValue(node);
+        }
+        if (!(node == null ? void 0 : node.__keyword)) {
+          const result = await asyncQueue.addAsync(createParams(props.wordbook, props.autograph, field.value, node, fieldKey.value));
+          if (!node) {
+            optionsRef.value = result.map((option) => enrichKeywordOption(option, keyword));
+          } else {
+            if (!result.length)
+              return updateValue(node);
+            node.children = result.map((option) => enrichChildOption(option, node, depth.value));
+          }
+        } else {
+          if (!isString(node.id_link))
+            return Promise.reject();
+          const linkList = parseLinkFromString2List(node.id_link);
+          const primaryKeyOptions = await fetchPrimaryKeyValue(linkList);
+          if (!primaryKeyOptions)
+            return Promise.reject();
+          const {
+            lastOption,
+            options
+          } = generateOptionWithIdList(primaryKeyOptions, linkList);
+          await fetchData(lastOption);
+          if (isEmpty(lastOption.children)) {
+            valueRef.value = sortOptionWithIdList(primaryKeyOptions, linkList);
+            showRef.value = false;
+            return Promise.reject();
+          } else {
+            optionsRef.value = options;
+            return lastOption;
+          }
+        }
+      } catch (e) {
+        isString(e) && formRenderLog(e);
+      }
+      function enrichChildOption(option, parent, depth2) {
+        return {
+          ...option,
+          parent,
+          isLeaf: getNodeDepth(parent) + 1 >= depth2
+        };
+      }
+      function enrichKeywordOption(option, keyword2) {
+        option.__keyword = !!keyword2;
+        option.isLeaf = !!keyword2;
+        return option;
+      }
+      function updateValue(node2) {
+        valueRef.value = createOptionValue(node2);
+        showRef.value = false;
+        return Promise.reject();
+      }
+      function sortOptionWithIdList(options, idList) {
+        return idList.map((id) => {
+          return options.find((option) => option[valueKey.value] === id);
+        });
+      }
+      function generateOptionWithIdList(options, idList) {
+        let lastOption = options[0];
+        const resultOption = idList.reduce((res, id, index) => {
+          const option = getTargetOption(options, id);
+          if (index === 0) {
+            lastOption = option;
+            return [option];
+          }
+          Object.assign(option, {
+            parent: lastOption,
+            isLeaf: index + 1 >= depth.value
+          });
+          lastOption.children = [option];
+          lastOption = option;
+          return res;
+        }, []);
+        return {
+          options: resultOption,
+          lastOption
+        };
+        function getTargetOption(options2, value) {
+          return options2.find((o) => o[valueKey.value] === value);
+        }
+      }
+      function getNodeDepth(node2) {
+        let result = 1;
+        let parent = node2.parent;
+        while (parent) {
+          result++;
+          parent = parent.parent;
+        }
+        return result;
+      }
+      function parseLinkFromString2List(linkString) {
+        return linkString.split("_").filter((s) => s);
+      }
+      function createParams(wordbook, autograph, field2, node2, key2) {
+        const paramsAdaptorMap = {
+          autograph: () => autograph,
+          wordbookId: "id",
+          wordbookType: "type",
+          fieldKeys: () => wordbook.search_key ? JSON.stringify(wordbook.search_key) : void 0,
+          conObj: () => JSON.stringify(createConfigObject(wordbook, keyword, node2)),
+          primaryKey: "primary_key",
+          levelKey: "level_key",
+          keyword: () => keyword,
+          page: () => 1
+        };
+        const params = Object.entries(paramsAdaptorMap).reduce((res, [k, v]) => {
+          res[k] = isString(v) ? wordbook[v] : isFunction(v) ? v() : void 0;
+          return res;
+        }, {});
+        return {
+          ...getSearchRequestInfo(),
+          params,
+          key: key2,
+          cache: props.requestCache
+        };
+      }
+      function createConfigObject(wordbook, keyword2, node2) {
+        if (keyword2)
+          return wordbook.conObj || [];
+        if (!node2)
+          return wordbook.conObjFirstLevel || [];
+        return [{
+          con: "EQ",
+          is_compare_field: false,
+          field_key: wordbook.level_key,
+          value: node2[valueKey.value]
+        }];
+      }
+    }
+    async function fetchPrimaryKeyValue(primaryKeys) {
+      if (!getSearchRequestInfo().primaryKeyUrl)
+        return [];
+      try {
+        return await asyncQueue.addAsync(createParams(props.wordbook, props.autograph, primaryKeys, fieldKey.value));
+      } catch (e) {
+        isString(e) && formRenderLog(e);
+      }
+      function createParams(wordbook, autograph, primaryKeys2, key2) {
+        const requestInfo = getSearchRequestInfo();
+        const params = {
+          autograph,
+          tableId: wordbook.id,
+          primaryKeyValue: primaryKeys2.join(","),
+          page: 1
+        };
+        return {
+          key: key2,
+          params,
+          ...requestInfo,
+          url: requestInfo.primaryKeyUrl,
+          cache: props.requestCache
+        };
+      }
+    }
+    function createOptionValue(node) {
+      const result = [];
+      let current = node;
+      while (current) {
+        result.unshift(omit(current, ["parent", "isLeaf", "__keyword", "children"]));
+        current = current.parent;
+      }
+      return result;
+    }
+    watch(() => props.wordbook, (wordbook, oldWordbook) => {
+      if (isEqual(wordbook, oldWordbook))
+        return;
+      optionsRef.value = [];
+      if (!wordbook)
+        return;
+      (valueRef.value || !props.lazyRequest) && fetchData();
+    }, {
+      immediate: true
+    });
+    const {
+      injectValueValidate,
+      injectValueWatchFromEmpty,
+      injectValueBindKey
+    } = useCommonInjection();
+    injectValueWatchFromEmpty(valueRef, fetchData);
+    injectValueValidate(valueRef);
+    const key = injectValueBindKey(valueRef);
+    return () => createVNode(SearchCascader, {
+      "value": valueRef.value,
+      "onUpdate:value": ($event) => valueRef.value = $event,
+      "show": showRef.value,
+      "onUpdate:show": ($event) => showRef.value = $event,
+      "options": optionsRef.value,
+      "key": key.value,
+      "labelKey": labelKey.value,
+      "valueKey": valueKey.value,
+      "search": fetchData,
+      "onFocus": visitedDecorator(field, props.onFocus)
+    }, {
+      empty: () => createVNode(script$1, null, null)
+    });
+  }
+});
+const LEVEL_SEARCH_CASCADE = connect(script, mapProps({
+  dataSource: "options"
+}, assignUpdateValue));
+
+export { LEVEL_SEARCH_CASCADE };

package/es/components/form-render/src/components/renderer/lineBar/FormCollapse.js

@@ -0,0 +1,57 @@
+import { defineComponent, ref, inject, openBlock, createElementBlock, createElementVNode, createTextVNode, toDisplayString, createBlock, unref, createVNode, withCtx, renderSlot } from 'vue';
+import '../../../../index.js';
+import { InjectionFormItemDepsCollector, FormItemLineBarDepKeyPrepend } from '../../../constants/index.js';
+import { ChevronDown, ChevronUp } from '@vicons/ionicons5';
+import { NCollapseTransition } from 'naive-ui';
+import _export_sfc from '../../../../../../_virtual/plugin-vue_export-helper.js';
+import { useFormField } from '../../../hooks/useFormField.js';
+
+const _hoisted_1 = {
+  class: "form-render__linebar",
+  "anchor-target": ""
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "FormCollapse",
+  props: {
+    show: { type: Boolean, default: true },
+    title: { type: String, default: "" },
+    disabled: { type: Boolean, default: false }
+  },
+  setup(__props) {
+    const props = __props;
+    const _show = ref(props.show);
+    function toggleShow() {
+      if (props.disabled)
+        return;
+      _show.value = !_show.value;
+    }
+    const { fieldKey } = useFormField();
+    const formItemDepsCollector = inject(InjectionFormItemDepsCollector);
+    formItemDepsCollector.setDeps(fieldKey.value, FormItemLineBarDepKeyPrepend + fieldKey.value, (v = true) => {
+      _show.value = v;
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("section", _hoisted_1, [
+        createElementVNode("header", {
+          class: "form-render__linebarHeader",
+          onClick: toggleShow
+        }, [
+          createTextVNode(toDisplayString(__props.title) + " ", 1),
+          _show.value ? (openBlock(), createBlock(unref(ChevronDown), { key: 0 })) : (openBlock(), createBlock(unref(ChevronUp), { key: 1 }))
+        ]),
+        createVNode(unref(NCollapseTransition), {
+          class: "form-render__linebarItem",
+          show: _show.value
+        }, {
+          default: withCtx(() => [
+            renderSlot(_ctx.$slots, "default")
+          ]),
+          _: 3
+        }, 8, ["show"])
+      ]);
+    };
+  }
+});
+var FormCollapse = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "FormCollapse.vue"]]);
+
+export { FormCollapse as default };

package/es/components/form-render/src/components/renderer/lineBar/FormCollapse.vue.d.ts

@@ -0,0 +1,54 @@
+declare const _default: import("vue").DefineComponent<{
+    show: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+        show: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        title: {
+            type: StringConstructor;
+            default: string;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & {}>>;
+    _show: import("vue").Ref<boolean>;
+    toggleShow: () => void;
+    fieldKey: import("vue").ComputedRef<string>;
+    formItemDepsCollector: import("../../../../../../../es/components/form-render").FormItemDepsCollector;
+    ChevronDown: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+    ChevronUp: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+    NCollapseTransition: any;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    show: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>>, {
+    disabled: boolean;
+    show: boolean;
+    title: string;
+}>;
+export default _default;

package/es/components/form-render/src/components/renderer/lineBar/index.d.ts

@@ -0,0 +1,53 @@
+export declare const LINEBAR: import("vue").DefineComponent<{
+    show: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+        show: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        title: {
+            type: StringConstructor;
+            default: string;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & {}>>;
+    _show: import("vue").Ref<boolean>;
+    toggleShow: () => void;
+    fieldKey: import("vue").ComputedRef<string>;
+    formItemDepsCollector: import("../../../hooks").FormItemDepsCollector;
+    ChevronDown: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+    ChevronUp: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+    NCollapseTransition: any;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    show: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>>, {
+    disabled: boolean;
+    show: boolean;
+    title: string;
+}>;

package/es/components/form-render/src/components/renderer/lineBar/index.js

@@ -0,0 +1,11 @@
+import { connect, mapProps } from '@formily/vue';
+import FormCollapse from './FormCollapse.js';
+
+const LINEBAR = connect(
+  FormCollapse,
+  mapProps((props, field) => {
+    return { ...props, title: field.title };
+  })
+);
+
+export { LINEBAR };

package/es/components/form-render/src/components/renderer/radio.d.ts

@@ -0,0 +1,34 @@
+import { AnyObject } from '../../../../../../es/shared/types';
+import { PropType } from 'vue';
+export declare const RADIO: import("vue").DefineComponent<{
+    value: {
+        type: (NumberConstructor | StringConstructor)[];
+    };
+    options: {
+        type: PropType<AnyObject[]>;
+        default: () => never[];
+    };
+    vertical: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    onChange: {};
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:value"[], "update:value", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: (NumberConstructor | StringConstructor)[];
+    };
+    options: {
+        type: PropType<AnyObject[]>;
+        default: () => never[];
+    };
+    vertical: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    onChange: {};
+}>> & {
+    "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+}, {
+    options: AnyObject[];
+    vertical: boolean;
+}>;

package/es/components/form-render/src/components/renderer/radio.js

@@ -0,0 +1,67 @@
+import { defineComponent, computed, createVNode } from 'vue';
+import { connect, mapProps } from '@formily/vue';
+import { isNumber } from 'lodash-es';
+import { NRadioGroup, NSpace, NRadio } from 'naive-ui';
+import '../../utils/index.js';
+import { assignUpdateValue, assignValueBindKey } from '../../utils/schema.js';
+
+const script = defineComponent({
+  props: {
+    value: {
+      type: [String, Number]
+    },
+    options: {
+      type: Array,
+      default: () => []
+    },
+    vertical: {
+      type: Boolean,
+      default: false
+    },
+    onChange: {}
+  },
+  emits: ["update:value"],
+  setup(props, {
+    emit
+  }) {
+    function dangerousTypeTransform(value) {
+      if (isNumber(value))
+        return value + "";
+      return value;
+    }
+    const valueRef = computed({
+      get() {
+        return dangerousTypeTransform(props.value);
+      },
+      set(v) {
+        emit("update:value", v);
+      }
+    });
+    return () => {
+      return createVNode(NRadioGroup, {
+        "value": valueRef.value,
+        "onUpdate:value": ($event) => valueRef.value = $event
+      }, {
+        default: () => [createVNode(NSpace, {
+          "vertical": props.vertical
+        }, {
+          default: () => {
+            var _a;
+            return [(_a = props.options) == null ? void 0 : _a.map((option) => {
+              return createVNode(NRadio, {
+                "value": option.value
+              }, {
+                default: () => [option.text]
+              });
+            })];
+          }
+        })]
+      });
+    };
+  }
+});
+const RADIO = connect(script, mapProps({
+  dataSource: "options"
+}, assignUpdateValue, assignValueBindKey));
+
+export { RADIO };

package/es/components/form-render/src/components/renderer/search.d.ts

@@ -0,0 +1,86 @@
+import { AnyObject, Func } from '../../../../../../es/shared/types';
+import { PropType } from 'vue';
+export declare const SEARCH: import("vue").DefineComponent<{
+    value: {
+        type: StringConstructor;
+    };
+    autograph: {
+        type: StringConstructor;
+        required: true;
+    };
+    lazyRequest: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    requestCache: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    wordbook: {
+        type: PropType<Partial<{
+            level_num: number;
+            id: string;
+            name: string;
+            render_key: string[];
+            search_key: string[];
+            primary_key: string;
+            type: string;
+            value_key: string;
+            level_key: string;
+            link_key: string;
+            link_key_split: string;
+            show_key: string[];
+            conObj: AnyObject[];
+            conObjFirstLevel: AnyObject[];
+        }>>;
+        required: true;
+    };
+    onFocus: {
+        type: PropType<Func<any[], any>>;
+    };
+    onChange: {};
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:value"[], "update:value", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: StringConstructor;
+    };
+    autograph: {
+        type: StringConstructor;
+        required: true;
+    };
+    lazyRequest: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    requestCache: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    wordbook: {
+        type: PropType<Partial<{
+            level_num: number;
+            id: string;
+            name: string;
+            render_key: string[];
+            search_key: string[];
+            primary_key: string;
+            type: string;
+            value_key: string;
+            level_key: string;
+            link_key: string;
+            link_key_split: string;
+            show_key: string[];
+            conObj: AnyObject[];
+            conObjFirstLevel: AnyObject[];
+        }>>;
+        required: true;
+    };
+    onFocus: {
+        type: PropType<Func<any[], any>>;
+    };
+    onChange: {};
+}>> & {
+    "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+}, {
+    lazyRequest: boolean;
+    requestCache: boolean;
+}>;