form-driver 0.3.14 → 0.4.1

package/src/types/MSetType.ts

@@ -1,34 +1,42 @@
-
 import { MUtil } from "../framework/MUtil";
 import { MFieldSchemaAnonymity, MValidationResult } from "../framework/Schema";
-import { MType} from "./MType";
+import { MType } from "./MType";
 
-import { validateArrayItemMinMax, validateRequired } from "../framework/Validator";
+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 {
+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){
+  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)){
+    for (let f of fs) {
+      if (MUtil.isEquals(f.value, v, schema.tolerate)) {
         vIsOk = true;
         break; // v校验ok
       }
     }
-    if(!vIsOk) {
-      if(openOption) {
+    if (!vIsOk) {
+      if (openOption) {
         openOption.required = true; // 既然勾上了开放选项，就必须填
         const vr = assembly.validate(openOption, v, path);
-        if(vr) { // 开放值无效
+        if (vr) {
+          // 开放值无效
           return vr;
         }
       } else {
-        return {message:"请重新选择", path};
+        return { message: "请重新选择", path };
       }
     }
   }
@@ -36,36 +44,59 @@ function validateCandidate(a:Assembly, schema:MFieldSchemaAnonymity, value:any,
 }
 
 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[]
-  } = {
+  change: (
+    isAdd: boolean,
+    newValue: any,
+    value: any[],
+    s: MFieldSchemaAnonymity,
+    isNeedSkipHandleOpenValue?: boolean
+  ) => 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 => {
+  toReadable: (
+    assembly: Assembly,
+    s: MFieldSchemaAnonymity,
+    vs: any
+  ): string => {
     const fs = MUtil.option(s);
-    if(_.isNil(vs)){
+    if (_.isNil(vs)) {
       return assembly.theme.READABLE_BLANK;
-    } else if(!_.isArray(vs)){
+    } 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 vs
+      .map((v: any) => {
+        for (let f of fs) {
+          if (f.value === v) {
+            return f.label ?? v;
+          }
         }
-      }
-      // 其他选项的内容前加上标识
-      return s.openOption ? `「${s.openOption.label}」${v}` : assembly.theme.READABLE_INVALID
-    }).join(", ");
+        // 其他选项的内容前加上标识
+        return s.openOption
+          ? `「${s.openOption.label}」${v}`
+          : assembly.theme.READABLE_INVALID;
+      })
+      .join(", ");
   },
 
-  standardValue: (a:Assembly, s:MFieldSchemaAnonymity, vs:any, strict:boolean):any => {
+  standardValue: (
+    a: Assembly,
+    s: MFieldSchemaAnonymity,
+    vs: any,
+    strict: boolean
+  ): any => {
     // 类型正确
-    if(!_.isArray(vs)){
+    if (!_.isArray(vs)) {
       return s.defaultValue;
     }
-    if(!strict){
+    if (!strict) {
       return vs;
     }
 
@@ -73,16 +104,22 @@ export const MSetType: MType & {
     const fs = MUtil.option(s);
     const result = [];
     let openValueFound = false; // 只能有一个开放值
-    for(let v of vs) {
+    for (let v of vs) {
       let matched = false;
-      for(let f of fs){
-        if(MUtil.isEquals(f.value, v, s.tolerate)){
-          result.push(v)
+      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的开放值
+      if (
+        (s.openOption ?? s.setOpen) &&
+        !matched &&
+        !openValueFound &&
+        !_.isNil(v)
+      ) {
+        // 使用第一个非nil的开放值
         openValueFound = true;
         result.push(v);
       }
@@ -98,40 +135,51 @@ export const MSetType: MType & {
    * @param s schema
    * @returns 修改后的集合，可能不是newValue对象
    */
-  change: (isAdd:boolean, newValue:any, prevValue:any[], s:MFieldSchemaAnonymity):any[] => {
-    if(isAdd) {
+  change: (
+    isAdd: boolean,
+    newValue: any,
+    prevValue: any[],
+    s: MFieldSchemaAnonymity,
+    isNeedSkipHandleOpenValue?: boolean
+  ): any[] => {
+    if (isAdd) {
       // 如果有多个不在option中的值，就只保留一个
-      prevValue = MSetType.clearOpenValue(s, prevValue, true);
+      if (!isNeedSkipHandleOpenValue) {
+        prevValue = MSetType.clearOpenValue(s, prevValue, true);
+      }
 
-      if(prevValue?.indexOf(newValue) >= 0){ // 如果要add的值已经存在了，直接返回即可
+      if (prevValue?.indexOf(newValue) >= 0) {
+        // 如果要add的值已经存在了，直接返回即可
         return prevValue;
       }
 
       // 处理排他选项
       const option = MUtil.option(s);
-      const newFs = _.find(option, {value:newValue});
+      const newFs = _.find(option, { value: newValue });
+      console.log("change 变化", option, prevValue, newValue, newFs);
       // 把所有exclusive跟自己不同的都清掉（newFs空是开放选项，不用管）
-      if(newFs) { 
-        prevValue = prevValue?.filter(v => {
-          const fs = _.find(option, {value:v});
-          if(fs && fs.exclusive !== newFs.exclusive) {
+      if (newFs) {
+        prevValue = prevValue?.filter((v) => {
+          const fs = _.find(option, { value: v });
+          if (fs && fs.exclusive !== newFs.exclusive) {
             return false;
           }
-          return  true;
-        })
+          return true;
+        });
       }
 
       // 新值加入
-      if(!_.isArray(prevValue)){
+      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){
+      while (max > 0 && prevValue.length > max) {
+        // 超过上限了，要删到上限为止，但不能删新加的那条
+        for (let d of prevValue) {
+          if (d !== newValue) {
             MUtil.arrayRemove(prevValue, d);
             break;
           }
@@ -140,10 +188,13 @@ export const MSetType: MType & {
     } else {
       MUtil.arrayRemove(prevValue, newValue);
 
-      // 如果有多个不在option中的值，就只保留一个
-      prevValue = MSetType.clearOpenValue(s, prevValue, true);
+      if (!isNeedSkipHandleOpenValue) {
+        // 如果有多个不在option中的值，就只保留一个
+        prevValue = MSetType.clearOpenValue(s, prevValue, true);
+      }
     }
-    if(!prevValue?.length) { // 如果删光了，或者只剩个开放选项，但是没有填
+    if (!prevValue?.length) {
+      // 如果删光了，或者只剩个开放选项，但是没有填
       prevValue = undefined;
     }
     return prevValue;
@@ -155,27 +206,33 @@ export const MSetType: MType & {
    * @param vs 值
    * @param keepOne 是否在schema允许的情况下（有openOption）保留一个有意义的（尽量非nil）开放选项
    */
-  clearOpenValue: (s:MFieldSchemaAnonymity, vs: any[], keepOne:boolean):any[] =>{
-    if(!vs){
+  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) {
+    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]
+        openValue = openValue ?? vs[i];
         openValueFound = true;
       }
     }
 
-    if(openValueFound && keepOne && (s.openOption ?? s.setOpen)) {
+    if (openValueFound && keepOne && (s.openOption ?? s.setOpen)) {
       result.push(openValue);
     }
 
@@ -184,8 +241,8 @@ export const MSetType: MType & {
 
   /**
    * 获取开放选项的下标。
-   * @param s 
-   * @param vs 
+   * @param s
+   * @param vs
    *   1. 优先把nil值作为开放选项（为了尽量保留有意义的值）
    *   2. 如果没有nil，最后一个在option中未出现的值作为开放选项
    *   例如
@@ -193,26 +250,26 @@ export const MSetType: MType & {
    *    openValueIndex(assembly, [a,b,c], [a, e, d,    f]) = 3
    * @returns -1表示没有找到开放选项
    */
-  openValueIndex: (s:MFieldSchemaAnonymity, vs: any[]):number =>{
-    if(!vs){
+  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 ++) {
+    for (let i = 0; i < vs.length; i++) {
       const v = vs[i];
-      if(_.isNil(v)) {
+      if (_.isNil(v)) {
         return i;
       }
-      if(! opt.find(o => MUtil.isEquals(v, o.value, s.tolerate)) ) {
+      if (!opt.find((o) => MUtil.isEquals(v, o.value, s.tolerate))) {
         openIdx = i;
       }
     }
     return openIdx;
   },
 
-  createDefaultValue: (assembly:Assembly, s:MFieldSchemaAnonymity):any =>{
-    if(s.defaultValue){
+  createDefaultValue: (assembly: Assembly, s: MFieldSchemaAnonymity): any => {
+    if (s.defaultValue) {
       return _.clone(s.defaultValue);
     } else {
       return []; // 默认不选

package/src/ui/editor/basic/ACheckBox.tsx

@@ -2,17 +2,17 @@ import React from "react";
 import { Checkbox, Modal } from "antd";
 import _ from "lodash";
 import { MUtil } from "../../../framework/MUtil";
-import { BaseViewer } from '../../BaseViewer';
-import { MEnumField, MProp, ValueConst } from '../../../framework/Schema';
-import { MSetType } from '../../../types/MSetType';
+import { BaseViewer } from "../../BaseViewer";
+import { MEnumField, MProp, ValueConst } from "../../../framework/Schema";
+import { MSetType } from "../../../types/MSetType";
 import { MFieldViewer } from "../../../framework/MFieldViewer";
 import { assembly } from "../../../framework/Assembly";
 
 function ACheckBoxLabel(field: MEnumField) {
   if (field.html) {
-    return <div dangerouslySetInnerHTML={{ __html: field.html }} />
+    return <div dangerouslySetInnerHTML={{ __html: field.html }} />;
   } else {
-    return field.label ?? field.value
+    return field.label ?? field.value;
   }
 }
 
@@ -31,47 +31,70 @@ export class ACheckBox extends BaseViewer {
   constructor(p: MProp) {
     super(p);
     this._enumFields = MUtil.option(this.props.schema);
-    this._enumValues = this._enumFields.map(e => e.value);
+    this._enumValues = this._enumFields.map((e) => e.value);
 
     const openOpt = p.schema.openOption ?? p.schema.setOpen;
-    if(openOpt) {
-      this._inputBoxValue = 
-        _.first(_.difference(super.getValue(), this._enumValues)) ?? 
+    if (openOpt) {
+      this._inputBoxValue =
+        _.first(_.difference(super.getValue(), this._enumValues)) ??
         assembly.types[openOpt.type].createDefaultValue(assembly, openOpt);
     }
   }
 
   _createBr() {
-    return this.props.schema.layoutHint == "h" ? undefined : <div key={MUtil.unique()} />;
+    return this.props.schema.layoutHint == "h" ? undefined : (
+      <div key={MUtil.unique()} />
+    );
   }
 
   element(ctx) {
-    let data: any[] = super.getValue()
+    let data: any[] = super.getValue();
 
     const openIndex = MSetType.openValueIndex(this.props.schema, data);
     let checkboxs: any[] = this._enumFields.map((m: any, index) => {
-      const isShow = MUtil.isShow(this.props.database, ctx.rootProps.schema?.objectFields, m.showIf)
+      const isShow = MUtil.isShow(
+        this.props.database,
+        ctx.rootProps.schema?.objectFields,
+        m.showIf
+      );
       if (!isShow) return null;
       return [
-        <Checkbox key={index} disabled={this.props.disable} checked={_.includes(data, m.value)} onChange={(e) => {
-          console.log(this.props.schema)
-          console.log(data)
-          const max = this.props.schema.max
-          if (max > 0 && e.target.checked) {
-            const len = data ? data.length : 0
-            // 选择第 max + 1 项时，提示并组织
-            if (len >= this.props.schema.max) {
-              Modal.info({title: `此题最多只能选择 ${max} 项`, okText: '确认', icon: null, centered: true, cancelText: ''})
-              return
+        <Checkbox
+          key={index}
+          disabled={this.props.disable}
+          checked={_.includes(data, m.value)}
+          onChange={(e) => {
+            console.log(this.props.schema);
+            console.log(data);
+            const max = this.props.schema.max;
+            if (max > 0 && e.target.checked) {
+              const len = data ? data.length : 0;
+              // 选择第 max + 1 项时，提示并组织
+              if (len >= this.props.schema.max) {
+                Modal.info({
+                  title: `此题最多只能选择 ${max} 项`,
+                  okText: "确认",
+                  icon: null,
+                  centered: true,
+                  cancelText: "",
+                });
+                return;
+              }
             }
-          }
-          super.changeValue(MSetType.change(e.target.checked, m.value, data, this.props.schema))
-        }}
-          >
+            super.changeValue(
+              MSetType.change(
+                e.target.checked,
+                m.value,
+                data,
+                this.props.schema
+              )
+            );
+          }}
+        >
           {ACheckBoxLabel(m)}
         </Checkbox>,
-        this._createBr()
-      ]
+        this._createBr(),
+      ];
     });
 
     // 开放选项
@@ -82,31 +105,56 @@ export class ACheckBox extends BaseViewer {
           key="opened:"
           checked={openIndex >= 0}
           onChange={(e) => {
-            if(e.target.checked) {
-              super.changeValue(MSetType.change(true, this._inputBoxValue, data, this.props.schema))
+            if (e.target.checked) {
+              super.changeValue(
+                MSetType.change(
+                  true,
+                  this._inputBoxValue,
+                  data,
+                  this.props.schema
+                )
+              );
             } else {
-              super.changeValue(MSetType.clearOpenValue(this.props.schema, data, false)) // 不能用MSetType.change，因为可能有多个开放值
+              super.changeValue(
+                MSetType.clearOpenValue(this.props.schema, data, false)
+              ); // 不能用MSetType.change，因为可能有多个开放值
             }
-          }}>
-          <span style={{ marginRight: "10px" }}>{this.props.schema.openOption.label ?? "其他"}</span>
-          <MFieldViewer morph={this.props.morph} schema={this.props.schema.openOption} database={this} path="_inputBoxValue" afterChange={(path: string, str: any, final: boolean) => {
-            const matchEnum = this._enumFields.find(e => e.value === str);
-            if (matchEnum) { // 不能让用户输入某个枚举值
-              this._inputBoxValue = "";
-              _.remove(data, (e) => !this._enumValues.includes(e))
-              if (!data.includes(str)) {
-                data.push(str);
-              }
-              super.changeValueEx(data, true, final);
-            } else {
-              const idx = data.findIndex(v => !this._enumValues.includes(v));
-              if (!_.isNil(idx)) {
-                this._inputBoxValue = str;
-                data[idx] = str;
-                super.changeValueEx(data, false, final);
+          }}
+        >
+          <span style={{ marginRight: "10px" }}>
+            {this.props.schema.openOption.label ?? "其他"}
+          </span>
+          <MFieldViewer
+            morph={this.props.morph}
+            schema={this.props.schema.openOption}
+            database={this}
+            path="_inputBoxValue"
+            afterChange={(path: string, str: any, final: boolean) => {
+              const matchEnum = this._enumFields.find((e) => e.value === str);
+              if (matchEnum) {
+                // 不能让用户输入某个枚举值
+                this._inputBoxValue = "";
+                _.remove(data, (e) => !this._enumValues.includes(e));
+                if (!data.includes(str)) {
+                  data.push(str);
+                }
+                super.changeValueEx(data, true, final);
+              } else {
+                const idx = data.findIndex(
+                  (v) => !this._enumValues.includes(v)
+                );
+                if (!_.isNil(idx)) {
+                  this._inputBoxValue = str;
+                  data[idx] = str;
+                  super.changeValueEx(data, false, final);
+                }
               }
-            }
-          }} parent={this.props.schema} forceValid={false} disable={openIndex < 0} style={{ width: "inherit" }} />
+            }}
+            parent={this.props.schema}
+            forceValid={false}
+            disable={openIndex < 0}
+            style={{ width: "inherit" }}
+          />
         </Checkbox>,
         this._createBr()
       );