@nutui/nutui-react 3.0.0 → 3.0.2

package/dist/cjs/packages/form/__tests__/merge.spec.js

@@ -0,0 +1,545 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+var _call_super = require("@swc/helpers/_/_call_super");
+var _class_call_check = require("@swc/helpers/_/_class_call_check");
+var _inherits = require("@swc/helpers/_/_inherits");
+var _sliced_to_array = require("@swc/helpers/_/_sliced_to_array");
+var _to_consumable_array = require("@swc/helpers/_/_to_consumable_array");
+var _wrap_native_super = require("@swc/helpers/_/_wrap_native_super");
+var _merge = require("../../../utils/merge");
+describe('merge', function() {
+    it('merges two objects', function() {
+        expect((0, _merge.merge)({
+            a: 1
+        }, {
+            b: 2
+        })).toStrictEqual({
+            a: 1,
+            b: 2
+        });
+    });
+    it('merges nested levels', function() {
+        expect((0, _merge.merge)({
+            a: 1
+        }, {
+            b: {
+                c: {
+                    d: 2
+                }
+            }
+        })).toStrictEqual({
+            a: 1,
+            b: {
+                c: {
+                    d: 2
+                }
+            }
+        });
+    });
+    it('clones the target', function() {
+        var input = {
+            a: 1,
+            b: {
+                c: {
+                    d: 2,
+                    e: [
+                        'x',
+                        'y',
+                        {
+                            z: {
+                                w: [
+                                    'k'
+                                ]
+                            }
+                        }
+                    ]
+                }
+            },
+            f: null,
+            g: undefined,
+            h: true
+        };
+        var original = {
+            a: 1,
+            b: {
+                c: {
+                    d: 2,
+                    e: [
+                        'x',
+                        'y',
+                        {
+                            z: {
+                                w: [
+                                    'k'
+                                ]
+                            }
+                        }
+                    ]
+                }
+            },
+            f: null,
+            g: undefined,
+            h: true
+        };
+        var output = (0, _merge.merge)(true, input);
+        input.b.c.d++;
+        input.b.c.e[2].z.w = null;
+        input.h = null;
+        expect(output).toStrictEqual(original);
+        input = original;
+        output = (0, _merge.merge)(true, input, {
+            a: 2
+        });
+        expect(output.a).toBe(2);
+        expect(input.a).toBe(1);
+    });
+    it('ignores the sources', function() {
+        var values = createNonPlainObjects();
+        var $merge = vi.fn().mockImplementation(_merge.merge);
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = values[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var value = _step.value;
+                expect($merge(value)).toStrictEqual({});
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        expect(values.length).toBeGreaterThan(0);
+        expect($merge).toBeCalledTimes(values.length);
+        expect(_merge.merge.apply(void 0, (0, _to_consumable_array._)(values).concat([
+            [
+                0,
+                1,
+                2
+            ]
+        ], (0, _to_consumable_array._)(values), [
+            {
+                a: 1
+            }
+        ], (0, _to_consumable_array._)(values), [
+            {
+                b: 2
+            }
+        ]))).toStrictEqual({
+            a: 1,
+            b: 2
+        });
+    });
+    it('does not merge non plain objects', function() {
+        var values = createNonPlainObjects();
+        expect(values.length).toBeGreaterThan(0);
+        var input = {};
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = Object.entries(values)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var _step_value = (0, _sliced_to_array._)(_step.value, 2), index = _step_value[0], value = _step_value[1];
+                input["value".concat(index)] = value;
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        var output = (0, _merge.merge)({}, input);
+        var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+        try {
+            for(var _iterator1 = Object.entries(values)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                var _step_value1 = (0, _sliced_to_array._)(_step1.value, 1), index1 = _step_value1[0];
+                var key = "value".concat(index1);
+                var inputValue = input[key];
+                var outputValue = output[key];
+                // eslint-disable-next-line no-restricted-globals
+                if (typeof outputValue === 'number' && isNaN(outputValue)) {
+                    // eslint-disable-next-line no-restricted-globals
+                    expect(isNaN(inputValue), key).toBeTruthy();
+                } else {
+                    expect(inputValue === outputValue, key).toBeTruthy();
+                }
+            }
+        } catch (err) {
+            _didIteratorError1 = true;
+            _iteratorError1 = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                    _iterator1.return();
+                }
+            } finally{
+                if (_didIteratorError1) {
+                    throw _iteratorError1;
+                }
+            }
+        }
+    });
+    it('is safe', function() {
+        expect((0, _merge.merge)({}, JSON.parse('{"__proto__": {"evil": true}}'))).toStrictEqual({});
+        expect({}.evil).toBeUndefined();
+    });
+});
+describe('clone', function() {
+    it('clones the input', function() {
+        var object1 = {
+            a: 1,
+            b: {
+                c: 2
+            }
+        };
+        var object2 = (0, _merge.clone)(object1);
+        expect(object1).toStrictEqual(object2);
+        expect(object1 === object2).toBeFalsy();
+        expect(object1.b === object2.b).toBeFalsy();
+    });
+    it('clones each item of the array', function() {
+        var object1 = [
+            {
+                a: 1,
+                b: {
+                    c: 2
+                }
+            }
+        ];
+        var object2 = (0, _merge.clone)(object1);
+        expect(object1).toStrictEqual(object2);
+        expect(object1 === object2).toBeFalsy();
+        expect(object1[0] === object2[0]).toBeFalsy();
+        expect(object1[0].b === object2[0].b).toBeFalsy();
+    });
+    it('returns the same input', function() {
+        var values = createNonPlainObjects();
+        var $clone = vi.fn().mockImplementation(_merge.clone);
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = values[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var value = _step.value;
+                var cloned = $clone(value);
+                // eslint-disable-next-line no-restricted-globals
+                if (typeof cloned === 'number' && isNaN(cloned)) {
+                    // eslint-disable-next-line no-restricted-globals
+                    expect(isNaN(value)).toBeTruthy();
+                } else if (Array.isArray(cloned)) {
+                    expect(Array.isArray(value)).toBeTruthy();
+                } else {
+                    expect(cloned === value).toBeTruthy();
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        expect(values.length).toBeGreaterThan(0);
+        expect($clone).toBeCalledTimes(values.length);
+    });
+});
+describe('recursive', function() {
+    it('merges recursively', function() {
+        expect((0, _merge.recursive)({
+            a: {
+                b: 1
+            }
+        }, {
+            a: {
+                c: 1
+            }
+        })).toStrictEqual({
+            a: {
+                b: 1,
+                c: 1
+            }
+        });
+        expect((0, _merge.recursive)({
+            a: {
+                b: 1,
+                c: 1
+            }
+        }, {
+            a: {
+                b: 2
+            }
+        })).toStrictEqual({
+            a: {
+                b: 2,
+                c: 1
+            }
+        });
+        expect((0, _merge.recursive)({
+            a: {
+                b: [
+                    1,
+                    2,
+                    3
+                ],
+                c: 1
+            }
+        }, {
+            a: {
+                b: [
+                    'a'
+                ]
+            }
+        })).toStrictEqual({
+            a: {
+                b: [
+                    'a'
+                ],
+                c: 1
+            }
+        });
+        expect((0, _merge.recursive)({
+            a: {
+                b: {
+                    b: 2
+                },
+                c: 1
+            }
+        }, {
+            a: {
+                b: 2
+            }
+        })).toStrictEqual({
+            a: {
+                b: 2,
+                c: 1
+            }
+        });
+    });
+    it('clones recursively', function() {
+        var test1 = {
+            a: {
+                b: 1
+            }
+        };
+        expect((0, _merge.recursive)(true, test1, {
+            a: {
+                c: 1
+            }
+        })).toStrictEqual({
+            a: {
+                b: 1,
+                c: 1
+            }
+        });
+        expect(test1).toStrictEqual({
+            a: {
+                b: 1
+            }
+        });
+        var test2 = {
+            a: {
+                b: 1,
+                c: 1
+            }
+        };
+        expect((0, _merge.recursive)(true, test2, {
+            a: {
+                b: 2
+            }
+        })).toStrictEqual({
+            a: {
+                b: 2,
+                c: 1
+            }
+        });
+        expect(test2).toStrictEqual({
+            a: {
+                b: 1,
+                c: 1
+            }
+        });
+        var test3 = {
+            a: {
+                b: [
+                    1,
+                    2,
+                    3
+                ],
+                c: 1
+            }
+        };
+        expect((0, _merge.recursive)(true, test3, {
+            a: {
+                b: [
+                    'a'
+                ]
+            }
+        })).toStrictEqual({
+            a: {
+                b: [
+                    'a'
+                ],
+                c: 1
+            }
+        });
+        expect(test3).toStrictEqual({
+            a: {
+                b: [
+                    1,
+                    2,
+                    3
+                ],
+                c: 1
+            }
+        });
+        var test4 = {
+            a: {
+                b: {
+                    b: 2
+                },
+                c: 1
+            }
+        };
+        expect((0, _merge.recursive)(true, test4, {
+            a: {
+                b: 2
+            }
+        })).toStrictEqual({
+            a: {
+                b: 2,
+                c: 1
+            }
+        });
+        expect(test4).toStrictEqual({
+            a: {
+                b: {
+                    b: 2
+                },
+                c: 1
+            }
+        });
+    });
+    it('does not merge non plain objects', function() {
+        var object = (0, _merge.recursive)({
+            map: {
+                length: 1
+            }
+        }, {
+            map: new Map()
+        });
+        expect(object.map).toBeInstanceOf(Map);
+    });
+    it('is safe', function() {
+        var payload = '{"__proto__": {"a": true}}';
+        expect((0, _merge.recursive)({}, JSON.parse(payload))).toStrictEqual({});
+        expect({}.a).toBeUndefined();
+        expect((0, _merge.recursive)({
+            deep: {}
+        }, JSON.parse(payload))).toStrictEqual({
+            deep: {}
+        });
+        expect({}.b).toBeUndefined();
+    });
+});
+describe('isPlainObject', function() {
+    it('returns true', function() {
+        expect((0, _merge.isPlainObject)({})).toBeTruthy();
+        expect((0, _merge.isPlainObject)({
+            v: 1
+        })).toBeTruthy();
+        expect((0, _merge.isPlainObject)(Object.create(null))).toBeTruthy();
+        expect((0, _merge.isPlainObject)({})).toBeTruthy();
+    });
+    it('returns false', function() {
+        var values = createNonPlainObjects();
+        var $isPlainObject = vi.fn().mockImplementation(_merge.isPlainObject);
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = values[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var value = _step.value;
+                expect($isPlainObject(value)).toBeFalsy();
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        expect(values.length).toBeGreaterThan(0);
+        expect($isPlainObject).toBeCalledTimes(values.length);
+    });
+});
+function createNonPlainObjects() {
+    var SubObject = /*#__PURE__*/ function(Object1) {
+        "use strict";
+        (0, _inherits._)(SubObject, Object1);
+        function SubObject() {
+            (0, _class_call_check._)(this, SubObject);
+            return (0, _call_super._)(this, SubObject, arguments);
+        }
+        return SubObject;
+    }((0, _wrap_native_super._)(Object));
+    return [
+        null,
+        undefined,
+        1,
+        '',
+        'str',
+        [],
+        [
+            1
+        ],
+        function() {},
+        function() {},
+        true,
+        false,
+        NaN,
+        Infinity,
+        function _class() {
+            "use strict";
+            (0, _class_call_check._)(this, _class);
+        },
+        new function _class() {
+            "use strict";
+            (0, _class_call_check._)(this, _class);
+        }(),
+        new Map(),
+        new Set(),
+        new Date(),
+        [],
+        new Date(),
+        /./,
+        /./,
+        SubObject,
+        new SubObject(),
+        Symbol('')
+    ];
+}

package/dist/cjs/packages/form/form.d.ts

@@ -6,7 +6,9 @@ export interface FormProps extends BasicComponent {
     initialValues: any;
     name: string;
     form: any;
+    disabled: boolean;
     divider: boolean;
+    validateTrigger: string | string[] | false;
     labelPosition: 'top' | 'left' | 'right';
     starPosition: 'left' | 'right';
     onFinish: (values: any) => void;

package/dist/cjs/packages/form/form.js

@@ -21,7 +21,9 @@ var _cell = /*#__PURE__*/ _interop_require_default._(require("../cell"));
 var defaultProps = (0, _object_spread_props._)((0, _object_spread._)({}, _typings.ComponentDefaults), {
     labelPosition: 'right',
     starPosition: 'left',
+    disabled: false,
     divider: false,
+    validateTrigger: 'onChange',
     onFinish: function onFinish(values) {},
     onFinishFailed: function onFinishFailed(values, errorFields) {}
 });
@@ -32,7 +34,7 @@ var PositionInfo = {
 };
 var Form = /*#__PURE__*/ _react.default.forwardRef(function(props, ref) {
     var classPrefix = 'nut-form';
-    var _$_object_spread = (0, _object_spread._)({}, defaultProps, props), className = _$_object_spread.className, style = _$_object_spread.style, footer = _$_object_spread.footer, children = _$_object_spread.children, initialValues = _$_object_spread.initialValues, divider = _$_object_spread.divider, onFinish = _$_object_spread.onFinish, onFinishFailed = _$_object_spread.onFinishFailed, labelPosition = _$_object_spread.labelPosition, starPosition = _$_object_spread.starPosition, form = _$_object_spread.form;
+    var _$_object_spread = (0, _object_spread._)({}, defaultProps, props), className = _$_object_spread.className, style = _$_object_spread.style, footer = _$_object_spread.footer, children = _$_object_spread.children, initialValues = _$_object_spread.initialValues, divider = _$_object_spread.divider, disabled = _$_object_spread.disabled, onFinish = _$_object_spread.onFinish, onFinishFailed = _$_object_spread.onFinishFailed, validateTrigger = _$_object_spread.validateTrigger, labelPosition = _$_object_spread.labelPosition, starPosition = _$_object_spread.starPosition, form = _$_object_spread.form;
     var formInstance;
     if (form !== undefined) {
         formInstance = form;
@@ -75,7 +77,12 @@ var Form = /*#__PURE__*/ _react.default.forwardRef(function(props, ref) {
     }, /*#__PURE__*/ _react.default.createElement(_cell.default.Group, {
         divider: divider
     }, /*#__PURE__*/ _react.default.createElement(_context.Context.Provider, {
-        value: formInstance
+        value: {
+            formInstance: formInstance,
+            labelPosition: labelPosition,
+            disabled: disabled,
+            validateTrigger: validateTrigger
+        }
     }, children), footer ? /*#__PURE__*/ _react.default.createElement(_cell.default, {
         className: "".concat(classPrefix, "-footer")
     }, footer) : null));

package/dist/cjs/packages/form/index.d.ts

@@ -2,11 +2,12 @@ import React from 'react';
 import { FormProps } from './form';
 import { FormItem } from '../formitem/formitem';
 import { FormInstance } from './types';
-import { useForm } from "./useform";
+import { useForm, useWatch } from "./useform";
 export type { FormItemRuleWithoutValidator, FormInstance, FormFieldEntity, } from './types';
 type CompoundedComponent = React.ForwardRefExoticComponent<Partial<FormProps> & Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange'> & React.RefAttributes<FormInstance>> & {
     Item: typeof FormItem;
     useForm: typeof useForm;
+    useWatch: typeof useWatch;
 };
 declare const InnerForm: CompoundedComponent;
 export default InnerForm;

package/dist/cjs/packages/form/index.js

@@ -16,4 +16,5 @@ var _useform = require("./useform");
 var InnerForm = _form.Form;
 InnerForm.Item = _formitem.FormItem;
 InnerForm.useForm = _useform.useForm;
+InnerForm.useWatch = _useform.useWatch;
 var _default = InnerForm;

package/dist/cjs/packages/form/style/form.scss

@@ -1,67 +1 @@
-.form-layout-right .nut-form-item-label {
-  text-align: right;
-  padding-right: 24px;
-  white-space: nowrap;
-}
 
-.form-layout-left .nut-form-item-label {
-  position: relative;
-  text-align: left;
-  padding-left: 12px;
-  white-space: nowrap;
-
-  .required {
-    display: block;
-    line-height: 1.5;
-    position: absolute;
-    left: 0.1em;
-  }
-}
-
-.form-layout-top .nut-form-item {
-  flex-direction: column;
-  align-items: flex-start;
-  white-space: nowrap;
-}
-
-.form-layout-top .nut-form-item-label {
-  padding-bottom: 4px;
-  display: block;
-  padding-right: 24px;
-}
-
-.form-layout-top .nut-form-item-body {
-  margin-left: 0;
-  width: 100%;
-}
-
-[dir='rtl'] .form-layout-right .nut-form-item-label,
-.nut-rtl .form-layout-right .nut-form-item-label {
-  text-align: left;
-  padding-right: 0;
-  padding-left: 24px;
-}
-
-[dir='rtl'] .form-layout-left .nut-form-item-label,
-.nut-rtl .form-layout-left .nut-form-item-label {
-  text-align: right;
-  padding-left: 0;
-  padding-right: 12px;
-
-  .required {
-    left: auto;
-    right: 0.1em;
-  }
-}
-
-[dir='rtl'] .form-layout-top .nut-form-item-label,
-.nut-rtl .form-layout-top .nut-form-item-label {
-  padding-right: 0;
-  padding-left: 24px;
-}
-
-[dir='rtl'] .form-layout-top .nut-form-item-body,
-.nut-rtl .form-layout-top .nut-form-item-body {
-  margin-left: 0;
-  margin-right: 0;
-}