cnhis-design-vue 3.1.14-beta.2 → 3.1.14-beta.5

package/es/packages/scale-view/src/components/formitem/r-address.d.ts

@@ -0,0 +1,34 @@
+declare const _default: import("vue").DefineComponent<{
+    form: {
+        type: ObjectConstructor;
+        default: () => void;
+    };
+    item: {
+        type: ObjectConstructor;
+        default: () => void;
+    };
+    isLock: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "scaleChange"[], "scaleChange", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    form: {
+        type: ObjectConstructor;
+        default: () => void;
+    };
+    item: {
+        type: ObjectConstructor;
+        default: () => void;
+    };
+    isLock: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    onScaleChange?: ((...args: any[]) => any) | undefined;
+}, {
+    form: Record<string, any>;
+    item: Record<string, any>;
+    isLock: boolean;
+}>;
+export default _default;

package/es/packages/scale-view/src/components/formitem/r-address.js

@@ -0,0 +1,225 @@
+import { defineComponent, reactive, computed, createVNode, resolveComponent } from 'vue';
+import { NSelect, NInput } from 'naive-ui';
+import allData from './address.js';
+import vexutils from '../../../../../src/utils/vexutils';
+
+var RAddress = defineComponent({
+  name: "RAddress",
+  components: {
+    NSelect,
+    NInput
+  },
+  props: {
+    form: {
+      type: Object,
+      default: () => {
+      }
+    },
+    item: {
+      type: Object,
+      default: () => {
+      }
+    },
+    isLock: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: ["scaleChange"],
+  setup(props, context) {
+    let state = reactive({
+      provinceValue: -1,
+      cityValue: -1,
+      areaValue: -1,
+      province: [{
+        value: -1,
+        label: "\u7701/\u81EA\u6CBB\u533A/\u76F4\u8F96\u5E02"
+      }],
+      city: [{
+        value: -1,
+        label: "\u5E02"
+      }],
+      area: [{
+        value: -1,
+        label: "\u533A/\u53BF"
+      }],
+      addressValue: "",
+      allValue: {}
+    });
+    const setting = props.item.setting || {
+      addressType: "province-city-district-address"
+    };
+    const addressType = computed(() => {
+      let setObj = {
+        addressType: "province-city-district-address"
+      };
+      if (vexutils.isJSON(setting)) {
+        setObj = JSON.parse(setting);
+      } else {
+        setObj = setting;
+      }
+      return setObj.addressType;
+    });
+    const hasProvince = computed(() => {
+      return addressType.value.includes("province");
+    });
+    const hasCity = computed(() => {
+      return addressType.value.includes("city");
+    });
+    const hasDistrict = computed(() => {
+      return addressType.value.includes("district");
+    });
+    const hasAddress = computed(() => {
+      return addressType.value.includes("address");
+    });
+    const objToArray = (obj) => {
+      if (!obj)
+        return [];
+      return Object.keys(obj).map((item) => {
+        return {
+          value: item,
+          label: obj[item]
+        };
+      });
+    };
+    const handleDef = () => {
+      var _a, _b, _c;
+      state.province.push(...objToArray(allData["86"]));
+      let value = props.form[props.item.val_key];
+      if (vexutils.isEmpty(value))
+        return;
+      let provinceValue = ((_a = value["province"]) == null ? void 0 : _a.key) || -1;
+      let cityValue = ((_b = value["city"]) == null ? void 0 : _b.key) || -1;
+      let areaValue = ((_c = value["area"]) == null ? void 0 : _c.key) || -1;
+      state.addressValue = value["address"];
+      state.allValue = JSON.parse(JSON.stringify(value));
+      handleProvince(provinceValue, value["province"], "no");
+      handleCity(cityValue, value["city"], "no");
+      handleArea(areaValue, value["area"], "no");
+    };
+    const initCity = () => {
+      state.city = [{
+        value: -1,
+        label: "\u5E02"
+      }];
+      state.cityValue = -1;
+      let allValue = state.allValue;
+      allValue.city = {
+        key: -1,
+        label: "\u5E02"
+      };
+    };
+    const initArea = () => {
+      state.area = [{
+        value: -1,
+        label: "\u533A/\u53BF"
+      }];
+      state.areaValue = -1;
+      let allValue = state.allValue;
+      allValue.area = {
+        key: -1,
+        label: "\u533A/\u53BF"
+      };
+    };
+    const handleProvince = (value, options, isInit) => {
+      state.provinceValue = value;
+      initCity();
+      initArea();
+      if (value != -1 && state.city.length === 1) {
+        state.city.push(...objToArray(allData[value]));
+      }
+      let allValue = state.allValue;
+      allValue.province = {
+        key: value,
+        label: options.label
+      };
+      allValue.address = state.addressValue;
+      if (isInit == "no")
+        return;
+      context.emit("scaleChange", allValue, props.item);
+    };
+    const handleCity = (value, options, isInit) => {
+      state.cityValue = value;
+      initArea();
+      if (value != -1 && state.area.length === 1) {
+        state.area.push(...objToArray(allData[value]));
+      }
+      let allValue = state.allValue;
+      allValue.city = {
+        key: value,
+        label: options.label
+      };
+      allValue.address = state.addressValue;
+      if (isInit == "no")
+        return;
+      context.emit("scaleChange", allValue, props.item);
+    };
+    const handleArea = (value, options, isInit) => {
+      state.areaValue = value;
+      let allValue = state.allValue;
+      allValue.area = {
+        key: value,
+        label: options.label
+      };
+      if (isInit == "no")
+        return;
+      context.emit("scaleChange", state.allValue, props.item);
+    };
+    const handleAddress = (val, isInit) => {
+      state.addressValue = val;
+      let allValue = state.allValue;
+      allValue.address = val;
+      if (isInit == "no")
+        return;
+      context.emit("scaleChange", state.allValue, props.item);
+    };
+    const renderProvince = () => {
+      return createVNode(resolveComponent("n-select"), {
+        "value": state.provinceValue,
+        "filterable": true,
+        "placeholder": "\u8BF7\u9009\u62E9",
+        "disabled": props.isLock,
+        "options": state.province,
+        "onUpdate:value": handleProvince
+      }, null);
+    };
+    const renderCity = () => {
+      return createVNode(resolveComponent("n-select"), {
+        "value": state.cityValue,
+        "filterable": true,
+        "placeholder": "\u8BF7\u9009\u62E9",
+        "disabled": props.isLock,
+        "options": state.city,
+        "onUpdate:value": handleCity
+      }, null);
+    };
+    const renderDistrict = () => {
+      return createVNode(resolveComponent("n-select"), {
+        "value": state.areaValue,
+        "filterable": true,
+        "placeholder": "\u8BF7\u9009\u62E9",
+        "disabled": props.isLock,
+        "options": state.area,
+        "onUpdate:value": handleArea
+      }, null);
+    };
+    const renderaddress = () => {
+      return createVNode(resolveComponent("n-input"), {
+        "value": state.addressValue,
+        "placeholder": "\u8BF7\u8F93\u5165",
+        "disabled": props.isLock,
+        "onUpdate:value": handleAddress
+      }, null);
+    };
+    handleDef();
+    return () => {
+      return createVNode("div", {
+        "class": "c-scale-address"
+      }, [createVNode("div", {
+        "class": "field-row"
+      }, [hasProvince.value && renderProvince(), hasCity.value && renderCity(), hasDistrict.value && renderDistrict()]), hasAddress.value && renderaddress()]);
+    };
+  }
+});
+
+export { RAddress as default };

package/es/packages/scale-view/src/components/formitem/r-cascader.d.ts

@@ -0,0 +1,43 @@
+declare const _default: import("vue").DefineComponent<{
+    form: {
+        type: ObjectConstructor;
+        default: () => void;
+    };
+    item: {
+        type: ObjectConstructor;
+        default: () => void;
+    };
+    isLock: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    getCascadeOptions: {
+        type: FunctionConstructor;
+        default: () => Promise<never[]>;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "scaleChange"[], "scaleChange", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    form: {
+        type: ObjectConstructor;
+        default: () => void;
+    };
+    item: {
+        type: ObjectConstructor;
+        default: () => void;
+    };
+    isLock: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    getCascadeOptions: {
+        type: FunctionConstructor;
+        default: () => Promise<never[]>;
+    };
+}>> & {
+    onScaleChange?: ((...args: any[]) => any) | undefined;
+}, {
+    form: Record<string, any>;
+    item: Record<string, any>;
+    isLock: boolean;
+    getCascadeOptions: Function;
+}>;
+export default _default;

package/es/packages/scale-view/src/components/formitem/r-cascader.js

@@ -0,0 +1,133 @@
+import { defineComponent, reactive, createVNode, resolveComponent } from 'vue';
+import { NCascader, NEmpty } from 'naive-ui';
+import script from '../LoadingCom.js';
+
+var RCascader = defineComponent({
+  name: "RCascader",
+  components: {
+    NCascader,
+    NEmpty,
+    LoadingCom: script
+  },
+  props: {
+    form: {
+      type: Object,
+      default: () => {
+      }
+    },
+    item: {
+      type: Object,
+      default: () => {
+      }
+    },
+    isLock: {
+      type: Boolean,
+      default: false
+    },
+    getCascadeOptions: {
+      type: Function,
+      default: () => Promise.resolve([])
+    }
+  },
+  emits: ["scaleChange"],
+  setup(props, context) {
+    let state = reactive({
+      cascaderValue: void 0,
+      curOptions: [],
+      fetching: false
+    });
+    const backshowValue = (list, val) => {
+      if (!list.length || !val || !val.length)
+        return;
+      let i = 0, len = val.length;
+      val[0];
+      let matchList = list;
+      let matchItem;
+      for (; i < len; i++) {
+        let item2 = val[i];
+        if (!matchList.length)
+          return false;
+        matchItem = matchList.find((v) => v.value === item2);
+        if (i === 0 && !matchItem)
+          return false;
+        if (i === len - 1 && !matchItem)
+          return false;
+        if (i === len - 1 && matchItem) {
+          break;
+        }
+        matchList = matchItem.children || [];
+      }
+      if (matchItem) {
+        state.cascaderValue = matchItem.theUniqueKey;
+      }
+    };
+    const handleOptions = (list, parent) => {
+      return list.map((v, i) => {
+        var _a;
+        v.curIndex = i + 1;
+        let level = v.level || 0;
+        v.path = `${v.curIndex}`;
+        if (level && parent) {
+          v.path = `${parent.path}-${v.curIndex}`;
+        }
+        v.theUniqueKey = v.path;
+        if (v.hasOwnProperty("children") && !v.children.length) {
+          delete v.children;
+        }
+        if ((_a = v.children) == null ? void 0 : _a.length) {
+          handleOptions(v.children, v);
+        }
+        return v;
+      });
+    };
+    const handleDef = async (value) => {
+      var _a;
+      if (!value || !Object.keys(value).length)
+        return;
+      let val = JSON.parse(JSON.stringify(value));
+      let defVal = props.form[props.item.val_key];
+      let options = [];
+      if (!((_a = val.targetSource) == null ? void 0 : _a.target_id)) {
+        options = handleOptions(val.options || []);
+        state.curOptions = options;
+        backshowValue(options, defVal);
+        return;
+      }
+      try {
+        state.fetching = true;
+        options = await props.getCascadeOptions(val);
+        state.curOptions = options;
+        backshowValue(options, defVal);
+        state.fetching = false;
+      } catch (err) {
+        state.fetching = false;
+      }
+    };
+    handleDef(props.item);
+    const cascaderChange = (value, options, pathValues) => {
+      let path = pathValues.map((v) => v.value);
+      state.cascaderValue = value;
+      context.emit("scaleChange", path, props.item);
+    };
+    return () => {
+      return createVNode(resolveComponent("n-cascader"), {
+        "value": state.cascaderValue,
+        "onUpdate:value": ($event) => state.cascaderValue = $event,
+        "filterable": true,
+        "clearable": true,
+        "placeholder": "\u8BF7\u9009\u62E9",
+        "check-strategy": "parent",
+        "value-field": "theUniqueKey",
+        "disabled": props.isLock,
+        "options": state.curOptions,
+        "show-path": true,
+        "cascade": false,
+        "on-update:value": cascaderChange
+      }, {
+        empty: () => state.fetching ? createVNode(script, null, null) : createVNode(NEmpty, null, null)
+      });
+    };
+  }
+});
+
+export { RCascader as default };

package/es/packages/scale-view/src/components/formitem/r-checkbox.d.ts

@@ -0,0 +1,43 @@
+declare const _default: import("vue").DefineComponent<{
+    form: {
+        type: ObjectConstructor;
+        default: () => void;
+    };
+    item: {
+        type: ObjectConstructor;
+        default: () => void;
+    };
+    isLock: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    inputLock: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "scaleChange"[], "scaleChange", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    form: {
+        type: ObjectConstructor;
+        default: () => void;
+    };
+    item: {
+        type: ObjectConstructor;
+        default: () => void;
+    };
+    isLock: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    inputLock: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    onScaleChange?: ((...args: any[]) => any) | undefined;
+}, {
+    form: Record<string, any>;
+    item: Record<string, any>;
+    isLock: boolean;
+    inputLock: boolean;
+}>;
+export default _default;