form-driver 0.1.0

package/src/types/MObjectType.ts

@@ -0,0 +1,89 @@
+import { MUtil } from "../framework/MUtil";
+import { MFieldSchemaAnonymity, MValidationResult } from "../framework/Schema";
+import { MType } from "./MType";
+import { validateRequired } from "../framework/Validator";
+import _, { result } from "lodash";
+import { Assembly } from '../framework/Assembly';
+
+export function validateObject(assembly:Assembly, schema:MFieldSchemaAnonymity, value:any, path:string): MValidationResult {
+  if(schema.objectFields){
+    let objectFieldMap = _.chain(schema.objectFields).keyBy('name').value();
+    if(schema.uispec?.segments){
+      const fields = _.flatten(schema.uispec?.segments.map(e=>e.fields)).filter(e=>_.isString(e)) as string[];
+      objectFieldMap = _.pick(objectFieldMap, fields);
+    }
+
+    const hideMap = MUtil.hideMap(value, schema.objectFields);    
+    for(let k in objectFieldMap){
+      const f = objectFieldMap[k];
+      if(hideMap[k]){ // 隐藏的字段不要校验
+        continue;
+      }
+      const r = assembly.validate(f, _.get(value, f.name), path ? path + "." + f.name : f.name);
+      if(r){
+        return r;
+      }
+    }
+  } else if(!_.isNil(value) && !_.isObject(value)){
+    return {message: "不是有效JSON", path};
+  }
+  return undefined;
+}
+
+/**
+ * JSON对象
+ * 注意：
+ * 1. string/number/boolean等不算有效的JSON对象
+ * 2. undefined/null在required=false时是有效的
+ */
+export const MObjectType: MType = {
+  validators: [validateRequired, validateObject],
+
+  /**
+   * 对象转换成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)) {
+      return vs["label"] ?? vs["name"] ?? vs["id"] ?? JSON.stringify(vs);
+    } else {
+      return result.toString();
+    }
+  },
+
+  standardValue: (assembly:Assembly, s:MFieldSchemaAnonymity, v:any, strict: boolean):any => {
+    // 类型正确
+    if(!_.isObject(v)) {
+      return s.defaultValue;
+    }
+
+    // 数值正确
+    // 注意，m3的object是开放的，允许数据中出现未定义的字段，所以只处理在schema里有的字段，不会改变schema里没有的字段
+    for(let f of s.objectFields) {
+      const type = assembly.types[f.type];
+      if(!type){
+        console.warn(`对象成员字段${f.name}的类型无效：${f.type}`)
+        continue;
+      }
+      v[f.name] = type.standardValue(assembly, f, v[f.name], strict);
+    }
+    return v;
+  },
+
+  createDefaultValue: (assembly:Assembly, schema:MFieldSchemaAnonymity):any =>{
+    let newItem;
+    if(schema.defaultValue){
+      newItem = _.cloneDeep(schema.defaultValue);
+    } else {
+      newItem = {};
+      for(let memberField of schema.objectFields){
+        newItem[memberField.name] = assembly.types[memberField.type]?.createDefaultValue(assembly, memberField);
+      }
+    }
+    return newItem;
+  }
+};

package/src/types/MSetType.ts

@@ -0,0 +1,220 @@
+
+import { MUtil } from "../framework/MUtil";
+import { MFieldSchemaAnonymity, MValidationResult } from "../framework/Schema";
+import { MType} from "./MType";
+
+import { validateArrayItemMinMax, 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);
+  const openOption = _.clone(schema.openOption ?? schema.setOpen)
+  
+  for(let v of value){
+    let vIsOk = false;
+    for(let f of fs){
+      if(MUtil.isEquals(f.value, v, schema.tolerate)){
+        vIsOk = true;
+        break; // v校验ok
+      }
+    }
+    if(!vIsOk) {
+      if(openOption) {
+        openOption.required = true; // 既然勾上了开放选项，就必须填
+        const vr = assembly.validate(openOption, v, path);
+        if(vr) { // 开放值无效
+          return vr;
+        }
+      } else {
+        return {message:"请重新选择", path};
+      }
+    }
+  }
+  return undefined;
+}
+
+export const MSetType: MType & {
+    change: (isAdd:boolean, newValue:any, value:any[], s:MFieldSchemaAnonymity)=>any[],
+    openValueIndex: (s:MFieldSchemaAnonymity, vs: any[])=>number,
+    clearOpenValue: (s:MFieldSchemaAnonymity, vs: any[], keepOne:boolean)=>any[]
+  } = {
+  validators: [validateRequired, validateCandidate, validateArrayItemMinMax],
+
+  toReadable: (assembly:Assembly, s:MFieldSchemaAnonymity, vs:any):string => {
+    const fs = MUtil.option(s);
+    if(_.isNil(vs)){
+      return assembly.theme.READABLE_BLANK;
+    } else if(!_.isArray(vs)){
+      return assembly.theme.READABLE_ERROR;
+    }
+    return vs.map((v:any) => {
+      for(let f of fs) {
+        if(f.value === v){
+          return f.label ?? v;
+        }
+      }
+      return s.openOption ? v : assembly.theme.READABLE_INVALID
+    }).join(", ");
+  },
+
+  standardValue: (a:Assembly, s:MFieldSchemaAnonymity, vs:any, strict:boolean):any => {
+    // 类型正确
+    if(!_.isArray(vs)){
+      return s.defaultValue;
+    }
+    if(!strict){
+      return vs;
+    }
+
+    // 数值正确
+    const fs = MUtil.option(s);
+    const result = [];
+    let openValueFound = false; // 只能有一个开放值
+    for(let v of vs) {
+      let matched = false;
+      for(let f of fs){
+        if(MUtil.isEquals(f.value, v, s.tolerate)){
+          result.push(v)
+          matched = true;
+          break;
+        }
+      }
+      if((s.openOption ?? s.setOpen)&& !matched && !openValueFound && !_.isNil(v)) { // 使用第一个非nil的开放值
+        openValueFound = true;
+        result.push(v);
+      }
+    }
+    return result;
+  },
+
+  /**
+   * 考虑exclusive和max的情况下，计算新增/删除一个值以后集合应该变成什么
+   * @param isAdd true=要向prevValue里新增newValue，false=要从prevValue里去除newValue
+   * @param newValue 要加入或者去除的值
+   * @param prevValue 数组形式的newValue加入或者去除前的集合
+   * @param s schema
+   * @returns 修改后的集合，可能不是newValue对象
+   */
+  change: (isAdd:boolean, newValue:any, prevValue:any[], s:MFieldSchemaAnonymity):any[] => {
+    if(isAdd) {
+      // 如果有多个不在option中的值，就只保留一个
+      prevValue = MSetType.clearOpenValue(s, prevValue, true);
+
+      if(prevValue?.indexOf(newValue) >= 0){ // 如果要add的值已经存在了，直接返回即可
+        return prevValue;
+      }
+
+      // 处理排他选项
+      const option = MUtil.option(s);
+      const newFs = _.find(option, {value:newValue});
+      // 把所有exclusive跟自己不同的都清掉（newFs空是开放选项，不用管）
+      if(newFs) { 
+        prevValue = prevValue?.filter(v => {
+          const fs = _.find(option, {value:v});
+          if(fs && fs.exclusive !== newFs.exclusive) {
+            return false;
+          }
+          return  true;
+        })
+      }
+
+      // 新值加入
+      if(!_.isArray(prevValue)){
+        prevValue = [];
+      }
+      prevValue.push(newValue);
+
+      // 处理max限制
+      const max = s.max ?? Number.MAX_VALUE;
+      while(max > 0 && prevValue.length > max) { // 超过上限了，要删到上限为止，但不能删新加的那条
+        for(let d of prevValue) {
+          if(d !== newValue){
+            MUtil.arrayRemove(prevValue, d);
+            break;
+          }
+        }
+      }
+    } else {
+      MUtil.arrayRemove(prevValue, newValue);
+
+      // 如果有多个不在option中的值，就只保留一个
+      prevValue = MSetType.clearOpenValue(s, prevValue, true);
+    }
+    if(!prevValue?.length) { // 如果删光了，或者只剩个开放选项，但是没有填
+      prevValue = undefined;
+    }
+    return prevValue;
+  },
+
+  /**
+   * 清除不在option中的选项
+   * @param s schema
+   * @param vs 值
+   * @param keepOne 是否在schema允许的情况下（有openOption）保留一个有意义的（尽量非nil）开放选项
+   */
+  clearOpenValue: (s:MFieldSchemaAnonymity, vs: any[], keepOne:boolean):any[] =>{
+    if(!vs){
+      return;
+    }
+    const opt = MUtil.option(s);
+    const result = [];
+    
+    let openValue;
+    let openValueFound = false;
+
+    for(let i = 0; i < vs.length; i ++) {
+      const matched = opt.find(o => MUtil.isEquals(vs[i], o.value, s.tolerate));
+      if(matched) {
+        result.push(matched.value);
+      } else {
+        openValue = openValue ?? vs[i]
+        openValueFound = true;
+      }
+    }
+
+    if(openValueFound && keepOne && (s.openOption ?? s.setOpen)) {
+      result.push(openValue);
+    }
+
+    return result;
+  },
+
+  /**
+   * 获取开放选项的下标。
+   * @param s 
+   * @param vs 
+   *   1. 优先把nil值作为开放选项（为了尽量保留有意义的值）
+   *   2. 如果没有nil，最后一个在option中未出现的值作为开放选项
+   *   例如
+   *    openValueIndex(assembly, [a,b,c], [a, e, null, f]) = 2
+   *    openValueIndex(assembly, [a,b,c], [a, e, d,    f]) = 3
+   * @returns -1表示没有找到开放选项
+   */
+  openValueIndex: (s:MFieldSchemaAnonymity, vs: any[]):number =>{
+    if(!vs){
+      return -1;
+    }
+    const opt = MUtil.option(s);
+    let openIdx = -1;
+    for(let i = 0; i < vs.length; i ++) {
+      const v = vs[i];
+      if(_.isNil(v)) {
+        return i;
+      }
+      if(! opt.find(o => MUtil.isEquals(v, o.value, s.tolerate)) ) {
+        openIdx = i;
+      }
+    }
+    return openIdx;
+  },
+
+  createDefaultValue: (assembly:Assembly, s:MFieldSchemaAnonymity):any =>{
+    if(s.defaultValue){
+      return _.clone(s.defaultValue);
+    } else {
+      return []; // 默认不选
+    }
+  },
+};

package/src/types/MStringType.ts

@@ -0,0 +1,27 @@
+
+import { MFieldSchemaAnonymity } from "../framework/Schema";
+import { EmtpyType, MType} from "./MType";
+import { validateRequired, validateStringMinMax, generateRegexValidate } from '../framework/Validator';
+import { Assembly } from '../framework/Assembly';
+import _ from "lodash";
+
+export const MStringType: MType = _.assign({}, EmtpyType, {
+  validators: [validateRequired, generateRegexValidate(/[^\s]|(^$)/, "不能全都填空格"), validateStringMinMax],
+
+  createDefaultValue: (assembly:Assembly, s:MFieldSchemaAnonymity):any =>{
+    return s.defaultValue ?? "";
+  },
+
+  toReadable: (assembly:Assembly, s:MFieldSchemaAnonymity, vs:any):string => {
+    if(_.isNil(vs)){
+      return assembly.theme.READABLE_BLANK;
+    }
+
+    if(!_.isString(vs)){
+      return assembly.theme.READABLE_INVALID;
+    }
+
+    return vs;
+  },
+
+});

package/src/types/MTelType.ts

@@ -0,0 +1,14 @@
+
+import { EmtpyType, MType} from "./MType";
+import { validateRequired, generateRegexValidate } from '../framework/Validator';
+import _ from "lodash";
+
+export const MCnPhoneType: MType = _.assign({}, EmtpyType, {
+  validators: [validateRequired, generateRegexValidate(/^1[3456789]\d{9}$/, "输入有效手机号")],
+});
+
+export const MEmailType: MType = _.assign({}, EmtpyType, {
+  validators: [validateRequired, generateRegexValidate(/^.+[@].+[.].+$/, "输入有效电子邮件地址")],
+});
+
+export const MTelType = MCnPhoneType;

package/src/types/MType.ts

@@ -0,0 +1,77 @@
+import { MFieldSchemaAnonymity } from '../framework/Schema';
+import { VALIDATOR } from "../framework/Validator";
+import { Assembly } from '../framework/Assembly';
+import _ from 'lodash';
+import { ClassType } from 'react';
+
+/**
+ * 定义一个数据类型的处理规则
+ */
+export interface MType {
+  /** 这种数据类型的验证器 */
+  validators: VALIDATOR[];
+
+  /** 将字段值转换成可读字符串的表达式 */
+  toReadable: (assembly:Assembly, s:MFieldSchemaAnonymity, v:any)=>string;
+
+  /**
+   * 预处理数据，使其符合schema描述
+   *  1. strict=true：处理后完全符合schema描述，例如set中option未出现的值，对于有tolerate配置的enum选项转换成option中的值 
+   *  2. strict=false：处理后数据类型符合schema描述，但值未必符合，例如保证set值是数组，但可能并非都是schema中定义的候选值
+   *  3. 即使strict模式，nil也是被允许的，表示值未填
+   *  4. 如果数据类型不正确，此方法应返回defaultValue
+   * @param strict 严格模式 
+   */
+  standardValue: (assembly:Assembly, s:MFieldSchemaAnonymity, v:any, strict:boolean)=>any;
+
+  /**
+   * 获取此类型的默认值
+   */
+  createDefaultValue:(assembly:Assembly, s:MFieldSchemaAnonymity)=>any;
+}
+
+/**
+ * 定义一个插件类型
+ */
+export interface PluginType {
+  /** 数据类型的字段 */
+  name: string;
+
+  /** 数据类型的处理规则 */
+  type: MType;
+
+   /** 数据类型的编辑模式 */
+   editor: ClassType<any, any, any> | string;
+
+   /** 数据类型的展示模式 */
+   readable: ClassType<any, any, any> | string;
+}
+
+export const EmtpyType = {
+  validators: [],
+  
+  createDefaultValue: (assembly:Assembly, s:MFieldSchemaAnonymity):any =>{
+    if(s.defaultValue){
+      return _.clone(s.defaultValue);
+    } else {
+      return undefined;
+    }
+  },
+
+  standardValue: (assembly:Assembly, s:MFieldSchemaAnonymity, v:any, strict:boolean):any => v,
+
+  toReadable: (assembly:Assembly, s:MFieldSchemaAnonymity, vs:any):string => {
+    if(_.isNil(vs)){
+      return assembly.theme.READABLE_BLANK;
+    }
+    return vs;
+  }
+}
+
+export function createDefaultValue(assembly:Assembly, s:MFieldSchemaAnonymity) {
+  if(s.defaultValue){
+    return _.clone(s.defaultValue);
+  } else {
+    return undefined;
+  }
+}

package/src/types/MVLPairType.ts

@@ -0,0 +1,35 @@
+
+import { MFieldSchemaAnonymity, MValidationResult } from "../framework/Schema";
+import { EmtpyType, MType} from "./MType";
+import { validateRequired } from "../framework/Validator";
+import { Assembly } from "../framework/Assembly";
+import _ from "lodash";
+
+function vlValidator(assembly:Assembly, schema:MFieldSchemaAnonymity, value:any, path:string): MValidationResult {
+  if(!value.label) {
+    return {message: "缺少标题，请重选此项", path}
+  } else if(!value.value) {
+    return {message: "缺少值，请重选此项", path}
+  } else{
+    return undefined;
+  }
+}
+
+/**
+ * 数据示例 { "value": 608793, "label": "test小二" }
+ */
+export const MVLPairType: MType = _.assign({}, EmtpyType, {
+  validators: [validateRequired, vlValidator],
+
+  toReadable: (assembly:Assembly, s:MFieldSchemaAnonymity, vs:any):string => {
+    if(_.isNil(vs)){
+      return assembly.theme.READABLE_BLANK;
+    }
+    if(_.isObject(vs) && !_.isArray(vs)) {
+      // @ts-ignore
+      return vs.label ?? vs.value ?? assembly.theme.READABLE_INVALID;
+    } else {
+      return assembly.theme.READABLE_INVALID;
+    } 
+  },
+});