@contentful/field-editor-single-line 1.4.16 → 1.5.0

package/dist/cjs/SingleLineEditor.js

@@ -57,17 +57,19 @@ function isSupportedFieldTypes(val) {
     return val === 'Symbol' || val === 'Text';
 }
 function SingleLineEditor(props) {
-    const { field, locales } = props;
+    const { field, isDisabled, isInitiallyDisabled = true, locales, onBlur, onFocus, withCharInformation = true, withCharValidation = true } = props;
+    console.log(`isDisabled => `, isDisabled);
     if (!isSupportedFieldTypes(field.type)) {
         throw new Error(`"${field.type}" field type is not supported by SingleLineEditor`);
     }
     const constraints = _fieldeditorshared.ConstraintsUtils.fromFieldValidations(field.validations, field.type);
     const checkConstraint = _fieldeditorshared.ConstraintsUtils.makeChecker(constraints);
     const direction = locales.direction[field.locale] || 'ltr';
+    const handleCheckConstraint = withCharValidation ? checkConstraint : ()=>true;
     return _react.createElement(_fieldeditorshared.FieldConnector, {
         field: field,
-        isInitiallyDisabled: props.isInitiallyDisabled,
-        isDisabled: props.isDisabled
+        isInitiallyDisabled: isInitiallyDisabled,
+        isDisabled: isDisabled
     }, ({ value, errors, disabled, setValue })=>{
         return _react.createElement("div", {
             "data-test-id": "single-line-editor"
@@ -77,27 +79,18 @@ function SingleLineEditor(props) {
             isInvalid: errors.length > 0,
             isDisabled: disabled,
             value: value || '',
-            onFocus: props.onFocus,
-            onBlur: props.onBlur,
+            onFocus: onFocus,
+            onBlur: onBlur,
             onChange: (e)=>{
                 setValue(e.target.value);
             }
-        }), props.withCharValidation && _react.createElement("div", {
+        }), withCharInformation && _react.createElement("div", {
             className: _styles.validationRow
         }, _react.createElement(_fieldeditorshared.CharCounter, {
             value: value || '',
-            checkConstraint: checkConstraint
-        }), _react.createElement(_fieldeditorshared.CharValidation, {
+            checkConstraint: handleCheckConstraint
+        }), withCharValidation && _react.createElement(_fieldeditorshared.CharValidation, {
             constraints: constraints
-        })), props.withCharValidation === false && _react.createElement("div", {
-            className: _styles.validationRow
-        }, _react.createElement(_fieldeditorshared.CharCounter, {
-            value: value || '',
-            checkConstraint: ()=>true
         })));
     });
 }
-SingleLineEditor.defaultProps = {
-    isInitiallyDisabled: true,
-    withCharValidation: true
-};

package/dist/cjs/SingleLineEditor.test.js

@@ -229,4 +229,30 @@ describe('SingleLineEditor', ()=>{
         expect(getByText('0 characters')).toBeInTheDocument();
         expect(queryByText('Requires between 100 and 1000 characters')).not.toBeInTheDocument();
     });
+    it('renders no validation message or counter if withCharInformation is false', ()=>{
+        const [field] = (0, _fieldeditortestutils.createFakeFieldAPI)((field)=>{
+            return {
+                ...field,
+                type: 'Symbol',
+                validations: [
+                    {
+                        size: {
+                            min: 100,
+                            max: 1000
+                        }
+                    }
+                ],
+                id: 'field-id'
+            };
+        });
+        const { queryByText } = (0, _react1.render)(_react.createElement(_SingleLineEditor.SingleLineEditor, {
+            field: field,
+            withCharValidation: false,
+            isInitiallyDisabled: false,
+            withCharInformation: false,
+            locales: (0, _fieldeditortestutils.createFakeLocalesAPI)()
+        }));
+        expect(queryByText('0 characters')).not.toBeInTheDocument();
+        expect(queryByText('Requires between 100 and 1000 characters')).not.toBeInTheDocument();
+    });
 });

package/dist/esm/SingleLineEditor.js

@@ -6,17 +6,19 @@ function isSupportedFieldTypes(val) {
     return val === 'Symbol' || val === 'Text';
 }
 export function SingleLineEditor(props) {
-    const { field, locales } = props;
+    const { field, isDisabled, isInitiallyDisabled = true, locales, onBlur, onFocus, withCharInformation = true, withCharValidation = true } = props;
+    console.log(`isDisabled => `, isDisabled);
     if (!isSupportedFieldTypes(field.type)) {
         throw new Error(`"${field.type}" field type is not supported by SingleLineEditor`);
     }
     const constraints = ConstraintsUtils.fromFieldValidations(field.validations, field.type);
     const checkConstraint = ConstraintsUtils.makeChecker(constraints);
     const direction = locales.direction[field.locale] || 'ltr';
+    const handleCheckConstraint = withCharValidation ? checkConstraint : ()=>true;
     return React.createElement(FieldConnector, {
         field: field,
-        isInitiallyDisabled: props.isInitiallyDisabled,
-        isDisabled: props.isDisabled
+        isInitiallyDisabled: isInitiallyDisabled,
+        isDisabled: isDisabled
     }, ({ value, errors, disabled, setValue })=>{
         return React.createElement("div", {
             "data-test-id": "single-line-editor"
@@ -26,27 +28,18 @@ export function SingleLineEditor(props) {
             isInvalid: errors.length > 0,
             isDisabled: disabled,
             value: value || '',
-            onFocus: props.onFocus,
-            onBlur: props.onBlur,
+            onFocus: onFocus,
+            onBlur: onBlur,
             onChange: (e)=>{
                 setValue(e.target.value);
             }
-        }), props.withCharValidation && React.createElement("div", {
+        }), withCharInformation && React.createElement("div", {
             className: styles.validationRow
         }, React.createElement(CharCounter, {
             value: value || '',
-            checkConstraint: checkConstraint
-        }), React.createElement(CharValidation, {
+            checkConstraint: handleCheckConstraint
+        }), withCharValidation && React.createElement(CharValidation, {
             constraints: constraints
-        })), props.withCharValidation === false && React.createElement("div", {
-            className: styles.validationRow
-        }, React.createElement(CharCounter, {
-            value: value || '',
-            checkConstraint: ()=>true
         })));
     });
 }
-SingleLineEditor.defaultProps = {
-    isInitiallyDisabled: true,
-    withCharValidation: true
-};

package/dist/esm/SingleLineEditor.test.js

@@ -184,4 +184,30 @@ describe('SingleLineEditor', ()=>{
         expect(getByText('0 characters')).toBeInTheDocument();
         expect(queryByText('Requires between 100 and 1000 characters')).not.toBeInTheDocument();
     });
+    it('renders no validation message or counter if withCharInformation is false', ()=>{
+        const [field] = createFakeFieldAPI((field)=>{
+            return {
+                ...field,
+                type: 'Symbol',
+                validations: [
+                    {
+                        size: {
+                            min: 100,
+                            max: 1000
+                        }
+                    }
+                ],
+                id: 'field-id'
+            };
+        });
+        const { queryByText } = render(React.createElement(SingleLineEditor, {
+            field: field,
+            withCharValidation: false,
+            isInitiallyDisabled: false,
+            withCharInformation: false,
+            locales: createFakeLocalesAPI()
+        }));
+        expect(queryByText('0 characters')).not.toBeInTheDocument();
+        expect(queryByText('Requires between 100 and 1000 characters')).not.toBeInTheDocument();
+    });
 });

package/dist/types/SingleLineEditor.d.ts

@@ -4,15 +4,19 @@ export interface SingleLineEditorProps {
     /**
      * is the field disabled initially
      */
-    isInitiallyDisabled: boolean;
+    isInitiallyDisabled?: boolean;
     /**
      * is the field manually disabled
      */
     isDisabled?: boolean;
+    /**
+     * whether validations should be rendered or not.
+     */
+    withCharInformation?: boolean;
     /**
      * whether char validation should be shown or not
      */
-    withCharValidation: boolean;
+    withCharValidation?: boolean;
     /**
      * sdk.field
      */
@@ -31,9 +35,3 @@ export interface SingleLineEditorProps {
     onFocus?: (event: React.FocusEvent<HTMLInputElement>) => void;
 }
 export declare function SingleLineEditor(props: SingleLineEditorProps): React.JSX.Element;
-export declare namespace SingleLineEditor {
-    var defaultProps: {
-        isInitiallyDisabled: boolean;
-        withCharValidation: boolean;
-    };
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/field-editor-single-line",
-  "version": "1.4.16",
+  "version": "1.5.0",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "types": "dist/types/index.d.ts",
@@ -50,5 +50,5 @@
   "publishConfig": {
     "registry": "https://npm.pkg.github.com/"
   },
-  "gitHead": "5744bed7b566437cb831312e84af7444b9047b69"
+  "gitHead": "aada768201894d98a6a71baa06696f6add49b692"
 }