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

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

@@ -0,0 +1,51 @@
+import { FieldItem } from '../../../../../../es/components/form-render';
+import { PropType } from 'vue';
+export declare const COMBINATION: import("vue").DefineComponent<{
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    value: {
+        type: ArrayConstructor;
+    };
+    maxGroupNum: {
+        type: NumberConstructor;
+    };
+    disabled: {
+        type: BooleanConstructor;
+    };
+    getProperties: {
+        type: PropType<() => FieldItem[]>;
+        default: () => never[];
+    };
+    onInput: {};
+    onBlur: {};
+    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<{
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    value: {
+        type: ArrayConstructor;
+    };
+    maxGroupNum: {
+        type: NumberConstructor;
+    };
+    disabled: {
+        type: BooleanConstructor;
+    };
+    getProperties: {
+        type: PropType<() => FieldItem[]>;
+        default: () => never[];
+    };
+    onInput: {};
+    onBlur: {};
+    onChange: {};
+}>> & {
+    "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+}, {
+    disabled: boolean;
+    title: string;
+    getProperties: () => FieldItem[];
+}>;

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

@@ -0,0 +1,104 @@
+import { defineComponent, ref, computed, watch, inject, createVNode } from 'vue';
+import { isNumber, isArray } from 'lodash-es';
+import '../../../index.js';
+import { useField, RecursionField, connect } from '@formily/vue';
+import { NButton, NIcon } from 'naive-ui';
+import { InjectionBusinessCollector } from '../../constants/index.js';
+import '../../utils/index.js';
+import { AddCircleOutline, RemoveCircle } from '@vicons/ionicons5';
+import { useFieldListAdaptor } from '../../hooks/useFieldListAdaptor.js';
+import { createObjSchema } from '../../utils/schema.js';
+
+const script = defineComponent({
+  name: "FormCombination",
+  props: {
+    title: {
+      type: String,
+      default: ""
+    },
+    value: {
+      type: Array
+    },
+    maxGroupNum: {
+      type: Number
+    },
+    disabled: {
+      type: Boolean
+    },
+    getProperties: {
+      type: Function,
+      default: () => []
+    },
+    onInput: {},
+    onBlur: {},
+    onChange: {}
+  },
+  emits: ["update:value"],
+  setup(props) {
+    const field = useField();
+    const currentGroupNum = ref(1);
+    const maxGroupNum = computed(() => {
+      if (!isNumber(props.maxGroupNum))
+        return Infinity;
+      if (props.maxGroupNum < 1)
+        return 0;
+      return ~~props.maxGroupNum;
+    });
+    watch(() => props.value, (value) => {
+      if (!isArray(value))
+        return;
+      currentGroupNum.value = Math.min(Math.max(value.length, 1), maxGroupNum.value);
+    }, {
+      immediate: true
+    });
+    function addGroup() {
+      currentGroupNum.value++;
+    }
+    async function removeGroup(idx) {
+      currentGroupNum.value--;
+      await field.value.remove(idx);
+    }
+    const collector = inject(InjectionBusinessCollector);
+    const {
+      schemaAdaptor
+    } = useFieldListAdaptor(collector);
+    return () => {
+      return createVNode("section", {
+        "class": "form-render__combination"
+      }, [createVNode("header", {
+        "class": "form-render__combinationHeader"
+      }, [createVNode("div", {
+        "class": "form-render__combinationHeaderText"
+      }, [props.title]), createVNode(NButton, {
+        "onClick": addGroup,
+        "type": "info",
+        "text": true,
+        "disabled": currentGroupNum.value >= maxGroupNum.value || props.disabled
+      }, {
+        icon: () => createVNode(NIcon, {
+          "component": AddCircleOutline
+        }, null),
+        default: () => "\u65B0\u589E"
+      })]), Array.from({
+        length: currentGroupNum.value
+      }).map((_, idx) => createVNode("section", {
+        "class": "form-render__combinationContent"
+      }, [createVNode(RecursionField, {
+        "schema": createObjSchema(schemaAdaptor(props.getProperties())),
+        "name": idx
+      }, null), idx === 0 ? null : createVNode(NButton, {
+        "text": true,
+        "type": "error",
+        "class": "form-render__combinationClose",
+        "onClick": () => removeGroup(idx)
+      }, {
+        icon: () => createVNode(NIcon, {
+          "component": RemoveCircle
+        }, null)
+      })]))]);
+    };
+  }
+});
+const COMBINATION = connect(script);
+
+export { COMBINATION };

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

@@ -0,0 +1,34 @@
+import { CSSProperties, PropType } from 'vue';
+export declare const COMPLEX: import("vue").DefineComponent<{
+    onChange: {};
+    span: {
+        type: NumberConstructor;
+        default: number;
+    };
+    display: {
+        type: PropType<"flex" | "grid">;
+        default: string;
+    };
+    wrapperStyle: {
+        type: PropType<CSSProperties>;
+        default: () => {};
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    onChange: {};
+    span: {
+        type: NumberConstructor;
+        default: number;
+    };
+    display: {
+        type: PropType<"flex" | "grid">;
+        default: string;
+    };
+    wrapperStyle: {
+        type: PropType<CSSProperties>;
+        default: () => {};
+    };
+}>>, {
+    span: number;
+    display: "flex" | "grid";
+    wrapperStyle: CSSProperties;
+}>;

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

@@ -0,0 +1,37 @@
+import { defineComponent, createVNode } from 'vue';
+import { connect, mapProps } from '@formily/vue';
+import '../../utils/index.js';
+import { assignUpdateValue } from '../../utils/schema.js';
+
+const script = defineComponent({
+  props: {
+    onChange: {},
+    span: {
+      type: Number,
+      default: 6
+    },
+    display: {
+      type: String,
+      default: "grid"
+    },
+    wrapperStyle: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  setup(props, {
+    slots
+  }) {
+    return () => {
+      return createVNode("section", {
+        "class": "form-render__complex"
+      }, [createVNode("section", {
+        "class": `form-render__complexContent--${props.display}`,
+        "style": props.wrapperStyle
+      }, [slots.default && slots.default()])]);
+    };
+  }
+});
+const COMPLEX = connect(script, mapProps(assignUpdateValue));
+
+export { COMPLEX };

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

@@ -0,0 +1,52 @@
+import { PropType } from 'vue';
+export declare const DATE: import("vue").DefineComponent<{
+    onChange: {};
+    value: {
+        type: StringConstructor;
+    };
+    validate: {
+        type: PropType<Partial<{
+            [key: string]: any;
+            obj_type: "password" | "sex" | "age" | "email" | "id_card" | "age_unit" | "mobile" | "telephone" | "birthday" | "bank_card" | "website" | "gestational_weeks" | "gestational_stage" | "customer_name";
+            vali_obj: string;
+            max_value: string | number;
+            min_value: string | number;
+            min_length: string | number;
+            max_length: string | number;
+            decimal_length: string | number;
+            regular_expression: string | RegExp;
+            regular_error_tip: string;
+        }>>;
+    };
+    valueFormat: {
+        type: StringConstructor;
+        default: string;
+    };
+}, () => 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<{
+    onChange: {};
+    value: {
+        type: StringConstructor;
+    };
+    validate: {
+        type: PropType<Partial<{
+            [key: string]: any;
+            obj_type: "password" | "sex" | "age" | "email" | "id_card" | "age_unit" | "mobile" | "telephone" | "birthday" | "bank_card" | "website" | "gestational_weeks" | "gestational_stage" | "customer_name";
+            vali_obj: string;
+            max_value: string | number;
+            min_value: string | number;
+            min_length: string | number;
+            max_length: string | number;
+            decimal_length: string | number;
+            regular_expression: string | RegExp;
+            regular_error_tip: string;
+        }>>;
+    };
+    valueFormat: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & {
+    "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+}, {
+    valueFormat: string;
+}>;

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

@@ -0,0 +1,171 @@
+import { defineComponent, computed, watch, createVNode, mergeProps } from 'vue';
+import { generateTimeFormat } from '../../../../../shared/utils/index.js';
+import { connect, mapProps } from '@formily/vue';
+import { isObject } from '@vueuse/core';
+import { format } from 'date-fns';
+import { NDatePicker } from 'naive-ui';
+import { useCommonInjection } from '../../hooks/useCommonInjection.js';
+import '../../utils/index.js';
+import { assignUpdateValue, assignClearBindVisited } from '../../utils/schema.js';
+import { businessDateParser } from '../../utils/business.js';
+
+const script = defineComponent({
+  props: {
+    onChange: {},
+    value: {
+      type: String
+    },
+    validate: {
+      type: Object
+    },
+    valueFormat: {
+      type: String,
+      default: "yyyy-MM-dd"
+    }
+  },
+  emits: ["update:value"],
+  setup(props, {
+    emit
+  }) {
+    const {
+      injectValueValidate,
+      injectValueBindKey
+    } = useCommonInjection();
+    injectValueValidate(() => props.value);
+    function minCurrentDate() {
+      var _a;
+      return ((_a = props.validate) == null ? void 0 : _a.min_date) === "currTime";
+    }
+    function maxCurrentDate() {
+      var _a;
+      return ((_a = props.validate) == null ? void 0 : _a.max_date) === "currTime";
+    }
+    function isDateDisabled(time) {
+      return minCurrentDate() && time < yesterday() || maxCurrentDate() && time > Date.now();
+      function yesterday() {
+        return Date.now() - 24 * 60 * 60 * 1e3;
+      }
+    }
+    function isTimeDisabled(time) {
+      const checkDate = new Date(time);
+      const currentDate = new Date();
+      const checkDateDuplicate = new Date(checkDate);
+      checkDateDuplicate.setHours(0);
+      checkDateDuplicate.setMinutes(0);
+      checkDateDuplicate.setSeconds(0);
+      return {
+        isHourDisabled,
+        isMinuteDisabled
+      };
+      function checkHour() {
+        return checkDate.getHours();
+      }
+      function currentHour() {
+        return currentDate.getHours();
+      }
+      function currentMinute() {
+        return currentDate.getMinutes();
+      }
+      function isOverDate() {
+        return checkDateDuplicate > currentDate;
+      }
+      function isHourDisabled(hour) {
+        if (isOverDate())
+          return false;
+        return minCurrentDate() && hour < currentHour() || maxCurrentDate() && hour > currentHour();
+      }
+      function isMinuteDisabled(minute) {
+        if (isOverDate())
+          return false;
+        if (checkHour() === currentHour()) {
+          return minCurrentDate() && minute < currentMinute() || maxCurrentDate() && minute > currentMinute();
+        }
+        return minCurrentDate() && checkHour() < currentHour() || maxCurrentDate() && checkHour() > currentHour();
+      }
+    }
+    const validateConfig = computed(() => {
+      const result = {};
+      if (isObject(props.validate)) {
+        const {
+          min_date,
+          max_date
+        } = props.validate;
+        if (min_date || max_date) {
+          result.isDateDisabled = isDateDisabled;
+          result.isTimeDisabled = isTimeDisabled;
+        }
+      }
+      return result;
+    });
+    const formatConfig = computed(() => {
+      return {
+        valueFormat: props.valueFormat,
+        format: props.valueFormat,
+        timePickerProps: {
+          format: generateTimeFormat(props.valueFormat)
+        }
+      };
+    });
+    function formatDate(value) {
+      if (!value)
+        return value;
+      return format(new Date(value), props.valueFormat);
+    }
+    let prevInputContent = "";
+    function onKeydown(evt) {
+      if (evt.key !== "Enter") {
+        prevInputContent = evt.target.value + evt.key;
+        return;
+      }
+      const result = businessDateParser(prevInputContent);
+      if (!result)
+        return;
+      const {
+        isTimeDisabled: isTimeDisabled2,
+        isDateDisabled: isDateDisabled2
+      } = validateConfig.value;
+      if (!isValidDate(result))
+        return;
+      valueRef.value = format(result, props.valueFormat);
+      function isValidDate(date) {
+        const dateDisabled = !isDateDisabled2 || isDateDisabled2(date.getTime());
+        if (dateDisabled)
+          return;
+        const {
+          isHourDisabled,
+          isMinuteDisabled
+        } = isTimeDisabled2 ? isTimeDisabled2(date.getTime()) : {};
+        const hourDisabled = !isHourDisabled || isHourDisabled(date.getHours());
+        if (hourDisabled)
+          return;
+        const minuteDisabled = !isMinuteDisabled || isMinuteDisabled(date.getMinutes());
+        if (minuteDisabled)
+          return;
+        return true;
+      }
+    }
+    watch(() => props.value, (value) => {
+      if (!value || formatDate(value) === value)
+        return;
+      emit("update:value", formatDate(value));
+    });
+    const valueRef = computed({
+      get: () => formatDate(props.value),
+      set: (value) => {
+        emit("update:value", value);
+        prevInputContent = "";
+      }
+    });
+    const key = injectValueBindKey(valueRef);
+    return () => createVNode(NDatePicker, mergeProps({
+      "key": key.value
+    }, validateConfig.value, formatConfig.value, {
+      "formatted-value": valueRef.value,
+      "onUpdate:formatted-value": ($event) => valueRef.value = $event,
+      "onKeydown": onKeydown
+    }), null);
+  }
+});
+const DATE = connect(script, mapProps(assignUpdateValue, assignClearBindVisited));
+
+export { DATE };

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

@@ -0,0 +1,9 @@
+export declare const FORM_ITEM: import("vue").DefineComponent<{
+    label: StringConstructor;
+    propertyKey: StringConstructor;
+    annotation: {};
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    label: StringConstructor;
+    propertyKey: StringConstructor;
+    annotation: {};
+}>>, {}>;

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

@@ -0,0 +1,89 @@
+import { defineComponent, inject, computed, createVNode } from 'vue';
+import { isVoidField } from '@formily/core';
+import { useField, connect, mapProps } from '@formily/vue';
+import { isString } from 'lodash-es';
+import { NFormItem } from 'naive-ui';
+import Annotation from '../../../../annotation-edit/index.js';
+import { InjectionAnnotation, InjectionFormUUID } from '../../constants/index.js';
+import { validateMessageParser } from '../../utils/index.js';
+import { dotEscape } from '../../utils/schema.js';
+
+const script = defineComponent({
+  props: {
+    label: String,
+    propertyKey: String,
+    annotation: {}
+  },
+  setup(props, {
+    slots
+  }) {
+    const annotation = inject(InjectionAnnotation);
+    const annotationContent = computed({
+      get() {
+        var _a, _b;
+        return (_b = (_a = annotation.value) == null ? void 0 : _a[props.propertyKey]) != null ? _b : "";
+      },
+      set(value) {
+        annotation.value = {
+          property: props.propertyKey,
+          value
+        };
+      }
+    });
+    function renderAnnotation() {
+      return createVNode(Annotation, {
+        "class": "form-render__formItemLabel--annotation",
+        "modelValue": annotationContent.value,
+        "onUpdate:modelValue": ($event) => annotationContent.value = $event
+      }, null);
+    }
+    const showAnnotation = computed(() => {
+      return annotation.value && props.annotation !== false;
+    });
+    const showLabel = computed(() => props.label && props.label !== " ");
+    const field = useField();
+    const uuid = inject(InjectionFormUUID);
+    const id = computed(() => {
+      return dotEscape(`${uuid}-${field.value.path.toString()}`);
+    });
+    function renderLabel() {
+      return showLabel.value ? createVNode("section", {
+        "class": "form-render__formItemLabel"
+      }, [createVNode("span", {
+        "class": ["form-render__formItemLabel--text", {
+          "has-annotation": showAnnotation.value
+        }]
+      }, [props.label]), showAnnotation.value ? renderAnnotation() : null]) : null;
+    }
+    return () => createVNode(NFormItem, {
+      id: id.value
+    }, {
+      ...slots,
+      label: renderLabel
+    });
+  }
+});
+const FORM_ITEM = connect(script, mapProps({
+  title: "label"
+}, (props, field) => {
+  const feedback = !isVoidField(field) ? field.selfErrors.length ? parseFeedback(field.selfErrors, props.fieldItem) : void 0 : void 0;
+  return {
+    ...props,
+    fieldItem: void 0,
+    required: isVoidField(field) ? void 0 : field.required,
+    class: "form-render__formItem",
+    style: {
+      "--form-item-column": props.span
+    },
+    feedback,
+    "validation-status": feedback ? "error" : void 0
+  };
+}));
+function parseFeedback(selfErrors, fieldItem) {
+  if (!isString(fieldItem.defined_error_msg) || !fieldItem.defined_error_msg) {
+    return selfErrors.map((message) => validateMessageParser(message, fieldItem)).join(",");
+  }
+  return validateMessageParser(fieldItem.defined_error_msg, fieldItem);
+}
+
+export { FORM_ITEM };

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

@@ -0,0 +1,3 @@
+import { Component } from 'vue';
+declare const _default: Record<string, Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>>;
+export default _default;

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

@@ -0,0 +1,47 @@
+import * as checkbox from './checkbox.js';
+import * as combination from './combination.js';
+import * as complex from './complex.js';
+import * as date from './date.js';
+import * as formItem from './formItem.js';
+import * as input from './input.js';
+import * as inputGroup from './inputGroup.js';
+import * as inputNumber from './inputNumber.js';
+import * as index from './jsonCombination/index.js';
+import * as labelSelect from './labelSelect.js';
+import * as levelSearchCascade from './levelSearchCascade.js';
+import * as index$1 from './lineBar/index.js';
+import * as radio from './radio.js';
+import * as search from './search.js';
+import * as searchCascade from './searchCascade.js';
+import * as select from './select.js';
+import * as simpleComponent from './simpleComponent.js';
+import * as slider from './slider.js';
+import * as _switch from './switch.js';
+import * as textarea from './textarea.js';
+import { separateMetaModule } from '../../../../../shared/utils/index.js';
+
+const modules = Object.assign({
+  "./checkbox.tsx": checkbox,
+  "./combination.tsx": combination,
+  "./complex.tsx": complex,
+  "./date.tsx": date,
+  "./formItem.tsx": formItem,
+  "./input.tsx": input,
+  "./inputGroup.ts": inputGroup,
+  "./inputNumber.tsx": inputNumber,
+  "./jsonCombination/index.tsx": index,
+  "./labelSelect.tsx": labelSelect,
+  "./levelSearchCascade.tsx": levelSearchCascade,
+  "./lineBar/index.ts": index$1,
+  "./radio.tsx": radio,
+  "./search.tsx": search,
+  "./searchCascade.tsx": searchCascade,
+  "./select.tsx": select,
+  "./simpleComponent.tsx": simpleComponent,
+  "./slider.tsx": slider,
+  "./switch.tsx": _switch,
+  "./textarea.tsx": textarea
+});
+var components = separateMetaModule(modules);
+
+export { components as default };

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

@@ -0,0 +1,23 @@
+export declare const INPUT: import("vue").DefineComponent<{
+    value: {
+        type: StringConstructor;
+    };
+    prefix: {
+        type: StringConstructor;
+    };
+    suffix: {
+        type: StringConstructor;
+    };
+}, () => 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;
+    };
+    prefix: {
+        type: StringConstructor;
+    };
+    suffix: {
+        type: StringConstructor;
+    };
+}>> & {
+    "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+}, {}>;

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

@@ -0,0 +1,52 @@
+import { defineComponent, computed, createVNode } from 'vue';
+import { useCommonInjection } from '../../hooks/useCommonInjection.js';
+import { createInputSlot } from '../../utils/index.js';
+import { connect, mapProps } from '@formily/vue';
+import { NInput } from 'naive-ui';
+import { assignUpdateValue, assignClearBindVisited } from '../../utils/schema.js';
+
+const script = defineComponent({
+  name: "FormInput",
+  props: {
+    value: {
+      type: String
+    },
+    prefix: {
+      type: String
+    },
+    suffix: {
+      type: String
+    }
+  },
+  emits: ["update:value"],
+  setup(props, {
+    emit
+  }) {
+    const valueRef = computed({
+      get: () => props.value,
+      set: (v) => emit("update:value", v)
+    });
+    const key = useCommonInjection().injectValueBindKey(valueRef);
+    const _slots = createInputSlot(props, (v) => {
+      return [createVNode("i", {
+        "style": {
+          color: "rgba(33,33,33,.4)"
+        }
+      }, [v])];
+    });
+    return () => {
+      return createVNode(NInput, {
+        "key": key.value,
+        "value": valueRef.value,
+        "onUpdate:value": ($event) => valueRef.value = $event
+      }, _slots.value);
+    };
+  }
+});
+const INPUT = connect(script, mapProps((props, field) => {
+  const _props = assignUpdateValue(props, field);
+  _props.allowInput = (value) => !value.startsWith(" ") && !value.endsWith(" ");
+  return _props;
+}, assignClearBindVisited));
+
+export { INPUT };