fix: Temporary Save 2025303

Author: mezhanglei

packages/form/src/components/Item/index.less

@@ -55,6 +55,8 @@
     .item__message {
       font-size: 12px;
       color: red;
+      white-space: normal;
+      word-break: break-word;
     }
 
     &--error .item__control {

packages/form/src/core.tsx

@@ -97,7 +97,9 @@ export const ItemCore = (props: ItemCoreProps) => {
     if (!isValidFormName(currentPath) || !form) return;
     // 回填初始值
     const initValue = initialValue === undefined ? deepGet(initialValues, currentPath) : initialValue;
-    form.setInitialValue(currentPath, initValue);
+    if (initValue !== undefined) {
+      form.setInitialValue(currentPath, initValue);
+    }
     onFieldsMounted && onFieldsMounted({ name: currentPath, value: initValue }, form?.getFieldValue());
     return () => {
       // 清除该表单域的props(在设置值的前面)
@@ -111,8 +113,21 @@ export const ItemCore = (props: ItemCoreProps) => {
   const bindChildren = (children: ItemCoreProps['children']) => {
     if (typeof children === 'function') {
       const bindProps = form && form.getBindProps(currentPath, value) || {};
-      return children({ className: errorClassName, form: form, bindProps: bindProps });
+      return children({ className: errorClassName, form, bindProps });
     } else {
+      const len = React.Children.count(children);
+      if (len === 1 && React.isValidElement(children)) {
+        const bindProps = form && form.getBindProps(currentPath, value) || {};
+        return React.cloneElement(children, {
+          ...bindProps,
+          [trigger]: (...args) => {
+            children?.props?.[trigger]?.(...args);
+            bindProps?.[trigger]?.(...args);
+          },
+          className: errorClassName,
+          form,
+        });
+      }
       return children;
     }
   };

packages/form/src/store.ts

@@ -2,7 +2,7 @@ import { deepGet, deepSet, getValuePropName, comparePrefix, FormPathType, isVali
 import { deepClone } from './utils/object';
 import { handleRules, isCanTrigger } from './validator';
 import { getRulesTriggers, mergeTriggers } from './core';
-import { isEmpty, isObject } from './utils/type';
+import { isArray, isEmpty, isObject } from './utils/type';
 import { FormItemProps } from './form-item';
 import { GetMapValueType, PathValue } from './typings';
 
@@ -171,7 +171,11 @@ export class SimpleForm<T = unknown> {
       this.notifyForm(path);
     };
 
+<<<<<<< Updated upstream
     if (isObject(args?.[0])) {
+=======
+    if (isObject(args?.[0]) || isArray(args?.[0])) {
+>>>>>>> Stashed changes
       Promise.all(Object.keys(args[0]).map((n) => setFormItemValue(n, args[0]?.[n], args[1])));
     } else {
       setFormItemValue(...args);

packages/form/src/validator/index.ts

@@ -68,6 +68,7 @@ export const handleRules = async (rules?: FormRule[], value?: unknown, eventName
 export const isCanTrigger = (eventName?: ItemCoreProps['trigger'], validateTrigger?: ItemCoreProps['validateTrigger']) => {
   // 默认允许触发
   if (eventName === undefined) return true;
+  if (typeof eventName === 'boolean') return eventName;
   if (validateTrigger === undefined) return true;
   if (typeof validateTrigger === 'string') {
     return validateTrigger === eventName;

packages/interpreter/src/constants.ts

@@ -101,10 +101,38 @@ const WORKER_CODE = [
   "close();",
   "};"];
 
-const placeholderGet_ =
-  function () { throw Error('Placeholder getter'); };
-const placeholderSet_ =
-  function () { throw Error('Placeholder setter'); };
+// 伪JS全局变量/方法
+const GLOBAL_TYPE = {
+  Function: 'Function',
+  Object: 'Object',
+  Array: 'Array',
+  String: 'String',
+  Boolean: 'Boolean',
+  Number: 'Number',
+  Date: 'Date',
+  RegExp: 'RegExp',
+  Error: 'Error',
+  Math: 'Math',
+  JSON: 'JSON'
+};
+
+const ERROR_KEYS = {
+  'EvalError': 'EvalError',
+  'RangeError': 'RangeError',
+  'ReferenceError': 'ReferenceError',
+  'SyntaxError': 'SyntaxError',
+  'TypeError': 'TypeError',
+  'URIError': 'URIError',
+};
+
+const ERROR_TYPES = {
+  [ERROR_KEYS.EvalError]: EvalError,
+  [ERROR_KEYS.RangeError]: RangeError,
+  [ERROR_KEYS.ReferenceError]: ReferenceError,
+  [ERROR_KEYS.SyntaxError]: SyntaxError,
+  [ERROR_KEYS.TypeError]: TypeError,
+  [ERROR_KEYS.URIError]: URIError,
+};
 
 export const Constants = {
   Completion,
@@ -121,6 +149,7 @@ export const Constants = {
   REGEXP_TIMEOUT,
   vm,
   WORKER_CODE,
-  placeholderGet_,
-  placeholderSet_,
+  GLOBAL_TYPE,
+  ERROR_KEYS,
+  ERROR_TYPES,
 };

packages/interpreter/src/constructor.ts

@@ -1,6 +1,15 @@
 
+import { Constants } from "./constants";
+import { isArray, isString } from "./global/type";
 import { AcornNode } from "./typings";
-import { getPropInPrototypeChain } from "./utils";
+import { legalArrayIndex, legalArrayLength } from "./utils/array";
+import { throwException } from "./utils/error";
+import {
+  bindClassPrototype,
+  getPropInPrototypeChain,
+  placeholderGet_,
+  placeholderSet_
+} from "./utils/object";
 
 // 对象构造函数
 class ObjectConstructor {
@@ -10,18 +19,19 @@ class ObjectConstructor {
   getter: { [key: string]: () => any };
   setter: { [key: string]: (value: any) => void };
   properties: { length: number; name?: string; message?: string };
-  proto: object | null;
+  proto: ObjectConstructor | null;
   class: string = 'Object';
   data: Date | RegExp | boolean | number | string | null = null; // 值
   preventExtensions?: boolean;
+  illegalConstructor?: boolean;
 
   constructor(proto) {
     this.getter = Object.create(null);
     this.setter = Object.create(null);
     this.properties = Object.create(null);
     this.proto = proto;
+    bindClassPrototype(ObjectConstructor, this);
   }
-
   toString() {
     if (!ObjectConstructor.currentInterpreter_) {
       // Called from outside an interpreter.
@@ -93,6 +103,184 @@ class ObjectConstructor {
     }
     return /** @type {(boolean|number|string)} */ (this.data); // 基础类型
   }
+  getProperty(name: string, script) {
+    if (script.getterStep_) {
+      throw Error('Getter not supported in that context');
+    }
+    name = String(name);
+    let obj: ObjectConstructor | null = this;
+    if (obj === undefined || obj === null) {
+      throwException(Constants.ERROR_KEYS.TypeError,
+        "Cannot read property '" + name + "' of " + obj, script);
+    }
+    if (typeof obj === 'object' && !(obj instanceof ObjectConstructor)) {
+      throw TypeError('Expecting native value or pseudo object');
+    }
+    if (name === 'length') {
+      // Special cases for magic length property.
+      if (isString(obj)) {
+        return String(obj).length;
+      }
+    } else if (name.charCodeAt(0) < 0x40) {
+      // Might have numbers in there?
+      // Special cases for string array indexing
+      if (isString(obj)) {
+        const n = legalArrayIndex(name);
+        if (!isNaN(n) && n < String(obj).length) {
+          return String(obj)[n];
+        }
+      }
+    }
+    while (obj !== null) {
+      if (obj.properties && name in obj.properties) {
+        const getter = obj.getter[name];
+        if (getter) {
+          script.getterStep_ = true;
+          return getter;
+        }
+        return obj.properties[name];
+      }
+      obj = obj.proto;
+    }
+    return undefined;
+  }
+  setProperty(name, value, opt_descriptor, script) {
+    const obj = this;
+    if (script?.setterStep_) {
+      // Getter from previous call to setProperty was not handled.
+      throw Error('Setter not supported in that context');
+    }
+    const strict = !script?.stateStack || script?.getScope()?.strict;
+    if (isString(obj)) {
+      const n = legalArrayIndex(name);
+      if (name === 'length' || (!isNaN(n) && n < String(obj).length)) {
+        // Can't set length or letters on String objects.
+        if (strict) {
+          throwException(Constants.ERROR_KEYS.TypeError, "Cannot assign to read only " +
+            "property '" + name + "' of String '" + obj.data + "'", script);
+        }
+        return;
+      }
+    }
+    if (isArray(obj)) {
+      // Arrays have a magic length variable that is bound to the elements.
+      const len = obj.properties.length;
+      if (name === 'length') {
+        if (opt_descriptor && !('value' in opt_descriptor)) {
+          return;
+        }
+        const maxLen = legalArrayLength(opt_descriptor && 'value' in opt_descriptor ? opt_descriptor['value'] : value);
+        if (isNaN(maxLen)) {
+          throwException(Constants.ERROR_KEYS.RangeError, 'Invalid array length', script);
+        }
+        if (maxLen < len) {
+          for (let key in obj.properties) {
+            const index = legalArrayIndex(key);
+            if (!isNaN(index) && index >= maxLen) {
+              delete obj.properties[index];
+            }
+          }
+        }
+      } else {
+        // Increase length if this index is larger.
+        const index = legalArrayIndex(name);
+        if (!isNaN(index)) {
+          obj.properties.length = Math.max(len, index + 1);
+        }
+      }
+    }
+    if (obj.preventExtensions && !(name in obj.properties)) {
+      if (strict) {
+        throwException(Constants.ERROR_KEYS.TypeError, "Can't add property '" + name +
+          "', object is not extensible", script);
+      }
+      return;
+    }
+    if (opt_descriptor) {
+      if (opt_descriptor && ('get' in opt_descriptor || 'set' in opt_descriptor) &&
+        ('value' in opt_descriptor || 'writable' in opt_descriptor)) {
+        throwException(Constants.ERROR_KEYS.TypeError, 'Invalid property descriptor. ' +
+          'Cannot both specify accessors and a value or writable attribute', script);
+      }
+      // Define the property.
+      const descriptor = {};
+      if ('get' in opt_descriptor && opt_descriptor['get']) {
+        obj.getter[name] = opt_descriptor['get'];
+        descriptor['get'] = placeholderGet_;
+      }
+      if ('set' in opt_descriptor && opt_descriptor['set']) {
+        obj.setter[name] = opt_descriptor['set'];
+        descriptor['set'] = placeholderSet_;
+      }
+      if ('configurable' in opt_descriptor) {
+        descriptor['configurable'] = opt_descriptor['configurable'];
+      }
+      if ('enumerable' in opt_descriptor) {
+        descriptor['enumerable'] = opt_descriptor['enumerable'];
+      }
+      if ('writable' in opt_descriptor) {
+        descriptor['writable'] = opt_descriptor['writable'];
+        delete obj.getter[name];
+        delete obj.setter[name];
+      }
+      if ('value' in opt_descriptor) {
+        descriptor['value'] = opt_descriptor['value'];
+        delete obj.getter[name];
+        delete obj.setter[name];
+      } else if (value !== Constants.VALUE_IN_DESCRIPTOR) {
+        descriptor['value'] = value;
+        delete obj.getter[name];
+        delete obj.setter[name];
+      }
+      try {
+        Object.defineProperty(obj.properties, name, descriptor);
+      } catch (e) {
+        throwException(Constants.ERROR_KEYS.TypeError, 'Cannot redefine property: ' + name, script);
+      }
+      // Now that the definition has suceeded, clean up any obsolete get/set funcs.
+      if ('get' in opt_descriptor && !opt_descriptor['get']) {
+        delete obj.getter[name];
+      }
+      if ('set' in opt_descriptor && !opt_descriptor['set']) {
+        delete obj.setter[name];
+      }
+    } else {
+      // Set the property.
+      if (value === Constants.VALUE_IN_DESCRIPTOR) {
+        throw ReferenceError('Value not specified');
+      }
+      // Determine the parent (possibly self) where the property is defined.
+      let defObj: ObjectConstructor | null = obj;
+      while (!(name in defObj.properties)) {
+        defObj = defObj.proto;
+        if (!defObj) {
+          // This is a new property.
+          defObj = obj;
+          break;
+        }
+      }
+      if (defObj.setter && defObj.setter[name]) {
+        script.setterStep_ = true;
+        return defObj.setter[name];
+      }
+      if (defObj.getter && defObj.getter[name]) {
+        if (strict) {
+          throwException(Constants.ERROR_KEYS.TypeError, "Cannot set property '" + name +
+            "' of object '" + obj + "' which only has a getter", script);
+        }
+      } else {
+        // No setter, simple assignment.
+        try {
+          obj.properties[name] = value;
+        } catch (_e) {
+          if (strict) {
+            throwException(Constants.ERROR_KEYS.TypeError, "Cannot assign to read only " +
+              "property '" + name + "' of object '" + obj + "'", script);
+          }
+        }
+      }
+    }
+  }
 };
 
 // 作用域构造函数