form-driver 0.1.0

package/src/index.ts

@@ -0,0 +1,33 @@
+import 'antd/dist/antd.css';
+import 'antd-mobile/dist/antd-mobile.css';
+import { Ajax } from './framework/Ajax';
+import { M3UISpecSegmentItem, MFieldSchema, M3UISpec, MFieldSchemaAnonymity } from './framework/Schema';
+import { MViewerDebug } from './framework/MViewerDebug';
+import { MORPH, VIEWER, assembly, MTheme, Assembly } from './framework/Assembly';
+import { ViewerState, Viewer, BaseViewer } from './ui/BaseViewer';
+import { MViewer, SubmitBar, useM3Database } from './framework/MViewer';
+import M3 from './framework/M3';
+import { MFieldViewer } from './framework/MFieldViewer';
+import { MContext } from './framework/MContext';
+import { MUtil } from './framework/MUtil';
+import { Segment } from "./ui/widget/Segment";
+import { UnderlineInputBox } from './ui/widget/UnderlineInputBox';
+import { SegmentEditSwitch, SegmentEditSwitchState } from './ui/widget/SegmentEditSwitch';
+import { ensureM3 } from './framework/Init';
+import Validator from './framework/Validator';
+import { MType, EmtpyType, createDefaultValue } from './types/MType';
+
+export {
+  M3,
+  MContext, MFieldViewer, BaseViewer, assembly, SegmentEditSwitch, Viewer, UnderlineInputBox, Segment, MUtil, Ajax,
+  MViewer,
+  MViewerDebug, SubmitBar,
+  useM3Database,
+  ensureM3,
+  Validator,
+  EmtpyType,
+  createDefaultValue,
+  Assembly
+};
+export type { M3UISpec, ViewerState, SegmentEditSwitchState, M3UISpecSegmentItem, MFieldSchema, MFieldSchemaAnonymity, MORPH, VIEWER, MType, MTheme };
+export default M3;

package/src/types/MArrayType.ts

@@ -0,0 +1,73 @@
+
+import { MFieldSchemaAnonymity, MValidationResult } from "../framework/Schema";
+import { MType} from "./MType";
+import _ from "lodash";
+import { generateJsPrototypeValidate, validateRequired } from "../framework/Validator";
+import { Assembly } from '../framework/Assembly';
+
+function arrayValidator(assembly:Assembly, schema:MFieldSchemaAnonymity, value:any, path:string): MValidationResult {
+  // 校验一下数组元素
+  if(schema.arrayMember){
+    for(let i = 0; i < value.length; i++){
+      let item = value[i];
+      const r = assembly.validate(schema.arrayMember, item, path + "[" + i + "]");
+      if(r){
+        return {message: "", path};; // 子元素校验没过，数组上不用展示信息
+      }
+    }
+  }
+  const min = schema.min ?? (schema.required ? 1: 0);
+  const max = schema.max ?? Number.MAX_VALUE;
+  if(value.length < min){
+    return {message: "最少" + min + "项", path};;
+  }
+  if(value.length > max) {
+    return {message: "最多" + schema.max + "项", path};
+  }
+  
+  return undefined;
+}
+
+export const MArrayType: MType = {
+  validators: [validateRequired, generateJsPrototypeValidate("[object Array]"), arrayValidator],
+
+  toReadable: (assembly:Assembly, s:MFieldSchemaAnonymity, vs:any):string => {
+    if(s.arrayMember?.type === "object"){
+      const olfs = s.arrayMember.objectLabelFields ?? [_.get(s.arrayMember, "objectFields[0].name") as string];
+      return vs?.map((v:any)=>{
+        const itemValueArr = [];
+        for(let ofs of olfs){
+          itemValueArr.push(v[ofs]);
+        }
+        return itemValueArr.join(",");
+      })?.join("\n") ?? assembly.theme.READABLE_BLANK;
+    } else {
+      return vs?.join(",") ?? assembly.theme.READABLE_BLANK;
+    }
+  },
+
+  standardValue: (assembly:Assembly, s:MFieldSchemaAnonymity, v:any, strict: boolean):any => {
+    if(!_.isArray(v)){
+      return s.defaultValue;
+    }
+    
+    const def = assembly.types[s.arrayMember?.type];
+    if(!def){
+      return v;
+    }
+    
+    for(let i = 0; i < v.length; i ++){
+      v[i] = def.standardValue(assembly, s.arrayMember, v[i], strict);
+    }
+
+    return v;
+  },
+
+  createDefaultValue:(assembly:Assembly, s:MFieldSchemaAnonymity) => {
+    if(s.defaultValue){
+      return _.cloneDeep(s.defaultValue);
+    } else {
+      return [];
+    }
+  }
+};

package/src/types/MCascadeType.ts

@@ -0,0 +1,35 @@
+
+import { MFieldSchemaAnonymity } from "../framework/Schema";
+import { MType} from "./MType";
+import _ from "lodash";
+import { generateSchemaValidate, validateRequired } from "../framework/Validator";
+import { Assembly } from '../framework/Assembly';
+
+/**
+ * 级联多选的值示例：
+ * 值类型：
+ * [ 
+ *  { "label": "jiangsu", "value": "jiangsu" },
+ *  { "label": "nanjing", "value": "nanjiong, chi" },
+ *  { "label": "nanjing", "value": "zhong hua men" }
+ * ]
+ */
+export const MCascadeType: MType = {
+  validators: [validateRequired, generateSchemaValidate({type:"array", arrayMember: {type: "vl"}, min:1}, "请重新填写") ],
+
+  toReadable: (assembly:Assembly, s:MFieldSchemaAnonymity, vs:any):string => {
+    return vs?.map(e=>e.label)?.join("/") ?? assembly.theme.READABLE_BLANK;
+  },
+
+  standardValue: (assembly:Assembly, s:MFieldSchemaAnonymity, v:any, strict:boolean):any => { // TODO 尚未实现
+    return v;
+  },
+
+  createDefaultValue:(assembly:Assembly, s:MFieldSchemaAnonymity) => {
+    if(s.defaultValue){
+      return _.cloneDeep(s.defaultValue);
+    } else {
+      return [];
+    }
+  }
+};

package/src/types/MCnAddressType.ts

@@ -0,0 +1,54 @@
+
+import { MFieldSchemaAnonymity } from "../framework/Schema";
+import { EmtpyType, MType} from "./MType";
+import { validateRequired } from "../framework/Validator";
+import { Assembly } from "../framework/Assembly";
+import { MGB2260Type } from "./MGB2260Type";
+import _ from "lodash";
+
+export const MCnAddress: MType = _.assign({}, EmtpyType, {
+  validators: [validateRequired],
+
+  toReadable: (assembly:Assembly, s:MFieldSchemaAnonymity, vs:any):string => {
+    if(!vs){
+      return assembly.theme.READABLE_BLANK;
+    }
+    if(!vs?.code && !vs.province){
+      return assembly.theme.READABLE_INVALID;
+    }
+    // 当传入的 database，没有 code，但有 province 时，反查 code 
+    if (vs.province && !vs.code) {
+      for (const p of MGB2260Type.gb2260) {
+        if (p.label === vs.province) {
+          if (vs.city && p.children) {
+            for (const c of p.children) {
+              if (c.label === vs.city) {
+                if (vs.district && c.children) {
+                  for (const d of c.children) {
+                    if (d.label === vs.district) {
+                      vs.code = d.value
+                      break
+                    }
+                  }
+                } else {
+                  vs.code = c.value
+                  break
+                }
+              }
+            }
+          } else {
+            vs.code = p.value
+            break
+          }
+        }
+      }
+    }
+    
+    const l = MGB2260Type.lookup(vs.code);
+    if(!l){
+      return assembly.theme.READABLE_INVALID;
+    }
+
+    return l.label.join("/") + "/" + (vs.address ?? assembly.theme.READABLE_BLANK);
+  }
+})

package/src/types/MDateRangeType.ts

@@ -0,0 +1,52 @@
+
+
+
+import { MFieldSchemaAnonymity } from "../framework/Schema";
+import { EmtpyType, MType} from "./MType";
+import { validateRequired } from "../framework/Validator";
+import { Assembly } from "../framework/Assembly";
+import moment from "moment";
+import _ from "lodash";
+
+function timeExpr(assembly:Assembly, v:any, tillNow:boolean, readableFormat):string {
+  if(tillNow){
+    return "至今";
+  }
+  if(!v){
+    return assembly.theme.READABLE_UNKNOWN;
+  }
+  return moment(v, "x").format(readableFormat);
+}
+
+export function timeRangeExpr(assembly:Assembly, from:number|string, to:number|string, tillNow:boolean, readableFormat:string = "YYYY年MM月DD日"):string {
+  return timeExpr(assembly, from, false, readableFormat) + " ~ " + timeExpr(assembly, to, tillNow, readableFormat)
+}
+
+export const MDateRangeType: MType & {toReadableN: (assembly:Assembly, s:MFieldSchemaAnonymity, vs:any)=>string|undefined} = _.assign({}, EmtpyType, {
+  validators: [validateRequired],
+  
+  toReadable: (assembly:Assembly, s:MFieldSchemaAnonymity, vs:any):string => {
+    if(_.isNil(vs)){
+      return assembly.theme.READABLE_BLANK
+    }
+    if(!_.isArray(vs)){
+      return assembly.theme.READABLE_INVALID;
+    }
+
+    return timeRangeExpr(assembly, vs[0], vs[1], vs[2], s.dateRange?.showTime ? "YYYY年MM月DD日 HH:mm:ss" : "YYYY年MM月DD日");
+  },
+
+  /**
+   * 同toReadable，但数据无效时返回nil
+   * @param assembly 
+   * @param s 
+   * @param vs 
+   * @returns 
+   */
+  toReadableN: (assembly:Assembly, s:MFieldSchemaAnonymity, vs:any):string|undefined => {
+    if(!_.isNil(vs) && _.isArray(vs)) {
+      return timeRangeExpr(assembly, vs[0], vs[1], vs[2], s.dateRange?.showTime ? "YYYY年MM月DD日 HH:mm:ss" : "YYYY年MM月DD日");
+    }
+    return undefined;
+  }
+});

package/src/types/MDateTimeType.ts

@@ -0,0 +1,53 @@
+
+import {validateDateMinMax, validateRequired} from '../framework/Validator';
+import { MFieldSchemaAnonymity } from '../framework/Schema';
+import { EmtpyType, MType} from "./MType";
+import moment from 'moment';
+import { Assembly } from '../framework/Assembly';
+import _ from 'lodash';
+
+export interface MDateTimeAntConf {
+  dataFormat: string,
+  readableFormat: string,
+  mode: undefined | 'date' | 'year' | 'month' | 'time';
+  showTime: boolean;
+}
+
+export const MDateTimeType:MType & {antConf:(schema:MFieldSchemaAnonymity)=>MDateTimeAntConf|undefined} = _.assign({}, EmtpyType, {
+  validators: [validateRequired, validateDateMinMax],
+
+  antConf: (schema:MFieldSchemaAnonymity):MDateTimeAntConf|undefined => {
+    let dataFormat:string|undefined = schema.dataFormat;
+    let readableFormat: string;
+    let mode: undefined | 'date' | 'year' | 'month' | 'time';
+    let showTime = false;
+    switch(schema.type) {
+      case "year": 
+        mode = "year"; dataFormat = dataFormat ?? 'YYYY'; readableFormat = 'YYYY'; break;
+      case "yearMonth": 
+        mode = "month"; dataFormat = dataFormat ?? 'YYYYMM'; readableFormat = 'YYYY-MM'; break;
+      case "yearMonthDay":  
+        mode = "date"; dataFormat = dataFormat ?? 'YYYYMMDD'; readableFormat = 'YYYY-MM-DD'; break;
+      case "datetime":  
+        mode = undefined; dataFormat = dataFormat ?? 'x'; readableFormat = 'YYYY-MM-DD HH:mm'; showTime = true; break;
+      // case "yearAndQuarter":
+      // case "yearAndWeek":
+      //   return MUtil.error(`移动端不支持${this.props.schema.type}`, this.props.schema);
+      default:
+        return undefined;
+    }
+    return {dataFormat, readableFormat, mode, showTime};
+  },
+
+  toReadable: (assembly:Assembly, schema:MFieldSchemaAnonymity, v:any):string => {
+    if(_.isNil(v)){
+      return assembly.theme.READABLE_BLANK;
+    }
+    let c = MDateTimeType.antConf(schema);
+    if(!c) {
+      return assembly.theme.READABLE_INVALID;
+    }
+    let asMoment = moment(v, c.dataFormat)
+    return asMoment.format(c.readableFormat);
+  }
+});

package/src/types/MDecorationType.ts

@@ -0,0 +1,6 @@
+
+import {EmtpyType} from "./MType";
+import _ from "lodash";
+
+/** HTML装饰物，并不修改数据 */
+export const MDecorationType = EmtpyType;

package/src/types/MEnumType.ts

@@ -0,0 +1,65 @@
+import { MUtil } from "../framework/MUtil";
+import {MValidationResult, MFieldSchemaAnonymity} from '../framework/Schema';
+import { MType} from "./MType";
+import { validateRequired } from "../framework/Validator";
+import { Assembly, assembly } from '../framework/Assembly';
+import _ from "lodash";
+
+// 选项是否合法、开放选项是否合法
+function validateCandidate(a:Assembly, schema:MFieldSchemaAnonymity, value:any, path:string): MValidationResult {
+  let fs = MUtil.option(schema);
+  for(let f of fs){
+    if(MUtil.isEquals(f.value, value, schema.tolerate)){
+      return undefined;
+    }
+  }
+  const openOption = _.clone(schema.openOption ?? schema.enumOpen)
+  if(openOption){
+    openOption.required = true; // 既然勾上了开放选项，就必须填， TODO 把开放选项标注成必填，可以在schema预处理做
+    return assembly.validate(openOption, value, "")
+  }
+  return {message:'请选择一个选项', path}
+}
+
+export const MEnumType: MType = {
+  validators: [validateRequired, validateCandidate],
+
+  createDefaultValue: (assembly:Assembly, s:MFieldSchemaAnonymity):any =>{
+    if(s.defaultValue){
+      return _.clone(s.defaultValue);
+    } else {
+      return undefined;
+    }
+  },
+
+  toReadable: (assembly:Assembly, s:MFieldSchemaAnonymity, v:any):string => {
+    const fs = MUtil.option(s);
+    for(let f of fs) {
+      if(f.value === v){
+        return f.label ?? v;
+      }
+    }
+    if(s.openOption){
+      return v;
+    } else {
+      return assembly.theme.READABLE_BLANK;
+    }
+  },
+
+  standardValue: (assembly:Assembly, s:MFieldSchemaAnonymity, v:any, strict:boolean):any => {
+    if(!strict) { // value的类型各种可能都有，如果不要求严格，就不用处理了
+      return v;
+    }
+    const fs = MUtil.option(s);
+    for(let f of fs){
+      if(MUtil.isEquals(f.value, v, s.tolerate)){
+        return v;
+      }
+    }
+    if(s.openOption || s.enumOpen) {
+      return v;
+    } else {
+      return undefined;
+    }
+  }
+}

package/src/types/MExperienceType.ts

@@ -0,0 +1,81 @@
+
+import { MFieldSchemaAnonymity, MValidationResult } from "../framework/Schema";
+import { EmtpyType, MType } from "./MType";
+import { validateRequired } from "../framework/Validator";
+import moment from "moment";
+import _ from "lodash";
+import { Assembly } from '../framework/Assembly';
+import { timeRangeExpr } from './MDateRangeType';
+
+export function validateExperience(assembly:Assembly, schema:MFieldSchemaAnonymity, value:any, path:string): MValidationResult {
+  // 空的不管，有validateRequired呢
+  if(_.isNil(value)){
+    return undefined
+  }
+  
+  if(!_.isArray(value)){
+    return {message: "数据损坏了", path};
+  }
+  const format = schema.dataFormat ?? "x";
+  let dim = [];
+  for(let item of value) {
+    let from = moment(item["from"], format).valueOf();
+    let to = moment(item["to"], format).valueOf();
+    let tillNow = !! item["tillNow"];
+    if(tillNow){
+      to = Number.MAX_VALUE;
+    }
+    if(!_.isFinite(from) || !_.isFinite(to)){
+      return {message: "没有填写完整", path};
+    }
+    dim.push({from, to, item});
+  }
+
+  dim.sort((a,b)=>{
+    if(a.from>b.from){
+      return 1 
+    } else if(a.from < b.from) {
+      return -1;
+    } else {
+      return 0;
+    }
+  });
+
+  // 看时间区间是不是有重叠
+  if(!schema.experience?.overlap) {
+    let prevTo = Number.MIN_VALUE;
+    for(let item of dim) {
+      if(item.from < prevTo){
+        return {message: "时间重叠了", path};
+      }
+      if(item.from > item.to) {
+        return {message: "结束时间不能早于开始时间", path};
+      }
+      prevTo = item.to;
+    }
+  }
+  return undefined;
+}
+
+export const MExperienceType: MType = _.assign({}, EmtpyType, {
+  validators: [validateRequired, validateExperience],
+
+  toReadable: (assembly:Assembly, s:MFieldSchemaAnonymity, vs:any):string => {
+    const result = [];
+    if(_.isNil(vs) || _.size(vs) < 1){
+      return assembly.theme.READABLE_BLANK;
+    }
+    if(!_.isArray(vs)) {
+      return assembly.theme.READABLE_INVALID;
+    }
+
+    for(let item of vs){
+      let exp:string[] = [];
+      for(let childschema of s.experience?.members ?? []){
+        exp.push(assembly.toReadable(childschema, item[childschema.name], item));
+      };
+      result.push(timeRangeExpr(assembly, item.from, item.to, item.tillNow) + "："+ exp.join("/"))
+    }
+    return result.join("\n");
+  }
+})

package/src/types/MFloatType.ts

@@ -0,0 +1,10 @@
+
+import { MFieldSchemaAnonymity, MValidationResult } from '../framework/Schema';
+import { createDefaultValue, EmtpyType, MType} from "./MType";
+import { validateRequired, validateNumberMinMax, generateRegexValidate } from '../framework/Validator';
+import { Assembly } from "../framework/Assembly";
+import _ from 'lodash';
+
+export const MFloatType: MType = _.assign({}, EmtpyType, {
+  validators: [validateRequired, generateRegexValidate(/(^(-?\d+)([.]\d+)?$)/, "请输入数字"), validateNumberMinMax],
+});

package/src/types/MGB2260Type.ts

@@ -0,0 +1,56 @@
+
+import { MFieldSchemaAnonymity } from "../framework/Schema";
+import { EmtpyType, MType} from "./MType";
+import gb2260 from './gb2260.json';
+import { Assembly } from "../framework/Assembly";
+import _ from "lodash";
+import { validateRequired } from "../framework/Validator";
+
+export interface GB2260CodeInfo {
+  label: string[];
+  code: string[];
+}
+
+export const MGB2260Type: MType & {lookup: (code: number|string)=>GB2260CodeInfo|undefined, gb2260:any} = _.assign({}, EmtpyType, {
+  validators: [validateRequired],
+  
+  toReadable: (assembly:Assembly, s:MFieldSchemaAnonymity, v:any):string => {
+    let ci = MGB2260Type.lookup(v);
+    if(!ci){
+      return assembly.theme.READABLE_INVALID;
+    }
+    return ci.label.join("/");
+  },
+
+  gb2260,
+
+  lookup: (code: number|string): GB2260CodeInfo|undefined => {
+    for(let prv of gb2260){
+      // @ts-ignore prv.value全是数字，ts并不知道
+      const pdiff = code - prv.value;
+      if(pdiff >= 0 && pdiff < 10000){
+        if(prv.children.length <= 0) { // 只有省级
+          return {label: [prv.label], code: [prv.value]};
+        }
+
+        for(let city of prv.children){
+          // @ts-ignore city.value全是数字，ts并不知道
+          const cdiff = code - city.value;
+          // @ts-ignore
+          if(cdiff === 0){
+            return {label: [prv.label, city.label], code: [prv.value, city.value]};
+          } else if(cdiff >0 && cdiff < 100){
+            // @ts-ignore
+            for(let dst of city.children ?? []){
+              // eslint-disable-next-line eqeqeq
+              if(dst.value == code) {
+                return {label: [prv.label, city.label, dst.label], code: [prv.value, city.value, dst.value]};
+              }
+            }
+          }
+        }
+      }
+    }
+    return undefined;
+  }
+})

package/src/types/MIntDiffType.ts

@@ -0,0 +1,6 @@
+
+import { MType} from "./MType";
+import _ from "lodash";
+import { MIntType } from "./MIntType";
+
+export const MIntDiffType: MType = MIntType;

package/src/types/MIntType.ts

@@ -0,0 +1,44 @@
+
+import { MFieldSchemaAnonymity, MValidationResult } from '../framework/Schema';
+import { EmtpyType, MType} from "./MType";
+import { validateRequired, validateNumberMinMax, generateRegexValidate } from '../framework/Validator';
+import { Assembly } from "../framework/Assembly";
+import _ from 'lodash';
+
+export const MIntType: MType = _.assign({}, EmtpyType, {
+  validators: [validateRequired, generateRegexValidate(/(^-?\d+$)/, "请输入整数"), validateNumberMinMax],
+
+  standardValue: (assembly:Assembly, s:MFieldSchemaAnonymity, v:any, strict: boolean):any => {
+    let r:number;
+
+    // 类型不能错
+    if(_.isString(v)) {
+      v = Math.round(parseInt(v));
+    }
+    
+    if(_.isNaN(v) || v === Infinity){
+      return s.defaultValue
+    } else if(_.isNumber(v)) {
+      r = v;
+    } else if(_.isBoolean(v)){
+      r = v ? 1 : 0
+    } else if(_.isDate(v)) { // 日期转换成时间戳
+      r = v.getTime();
+    } else {
+      return s.defaultValue;
+    }
+
+    if(!strict) {
+      return r;
+    }
+  
+    // 数值不能错
+    if(r < s.min) {
+      r = s.min;
+    } else if(r > s.max) {
+      r = s.max;
+    }
+    return v;
+  },
+
+});

package/src/types/MKvSetType.ts

@@ -0,0 +1,50 @@
+
+import { MEnumField, MFieldSchemaAnonymity, MValidationResult } from "../framework/Schema";
+import { EmtpyType, MType } from "./MType";
+import _ from "lodash";
+import { Assembly } from '../framework/Assembly';
+import { MUtil } from '../framework/MUtil';
+
+/**
+ * 类似这种题：
+ * B8: 您现在在做的事业务部门的岗位吗？
+ * 1. 是，具体职位是 _______
+ * 2. 否，我的部门是 _______
+ * 
+ * 数据结构
+ * {1:'CEO', 2:'营销'}
+ */
+export const MKvSetType: MType = _.assign({}, EmtpyType, {
+  validators: [(a:Assembly, schema:MFieldSchemaAnonymity, value:any, path:string): MValidationResult => {
+    if(schema.required){
+      if(_.isNil(value) || Object.keys(value).length == 0) {
+        return {message:'您还没有填完这一项', path};
+      }
+      for(let k in value){
+        if(_.isNil(value[k]) || value[k] == ""){
+          return {message:'您还没有填完这一项', path};
+        }
+      }
+    }
+    return undefined;
+  }],
+
+  /**
+   * 对象转换成readable文案时，会默认选择展示对象的label/name/id，如果都没有，展示JSON.stringify后的字符串
+   * @param assembly 
+   * @param s 
+   * @param vs 
+   */
+  toReadable: (assembly:Assembly, s:MFieldSchemaAnonymity, vs:any):string => {
+    if(_.isNil(vs)){
+      return assembly.theme.READABLE_BLANK;
+    } else if(_.isObject(vs)){
+      let fds = MUtil.standardFields(s.option);
+      return Object.keys(vs).map(k => {
+        return (_.find(fds, {"name": k}) as MEnumField)?.label ?? k + ":" + vs[k];
+      }).join(",");
+    } else {
+      return assembly.theme.READABLE_INVALID
+    }
+  }
+});

package/src/types/MMatrixType.ts

@@ -0,0 +1,52 @@
+
+import { MFieldSchemaAnonymity, MValidationResult } from "../framework/Schema";
+import { EmtpyType, MType} from "./MType";
+import { validateRequired } from "../framework/Validator";
+import { MUtil } from "../framework/MUtil";
+import _ from "lodash";
+import { Assembly } from '../framework/Assembly';
+
+export function validateMatrix(a:Assembly, schema:MFieldSchemaAnonymity, value:any, path:string): MValidationResult {
+  if(_.isNil(value)){
+    return undefined;
+  }
+
+  if(schema.matrix?.minY) {
+    let allXValue = MUtil.standardFields(schema.matrix?.x).map(e=>e.value);
+    let selectedXValue:any[] = [];
+    for(let k in value){
+      if(!k){
+        continue;
+      }
+      const xv = value[k];
+      if(_.isArray(xv)){
+        selectedXValue = selectedXValue.concat(xv);
+      } else {
+        selectedXValue.push(xv);
+      }
+    }
+    selectedXValue = _.uniq(selectedXValue);
+    const diff = _.difference(allXValue, selectedXValue);
+    if(diff.length > 0){
+      return {message: `您还没有填"${_.join(diff, ",")}"`, path}
+    }
+  }
+
+  if(schema.matrix?.minX) {
+    const yy = MUtil.standardFields(schema.matrix?.y);
+    for(let y of yy){
+      const yv = value[y.value?.toString()];
+      const n = _.isArray(yv) ? yv.length : (yv ? 1 : 0);
+      if(n < schema.matrix.minX){
+        return {message: `您还没有为"${y.label ?? y.value}"做选择`, path}
+      }
+    }
+  }
+  return undefined;
+}
+
+export const MMatrixType: MType = _.assign({}, EmtpyType, {
+  validators: [validateRequired, validateMatrix],
+
+  standardValue: (assembly:Assembly, s:MFieldSchemaAnonymity, v:any, strict:boolean):any => v, // TODO,矩阵要考虑 tolerate,strict 选项
+});